Merge pull request 'bump msrv version' (#165) from bump-msrv into main

Reviewed-on: #165

.gitignore

@@ -1,5 +1,9 @@
-/target
+target/
+
+output.log
 /Cargo.lock
 
+output.log
+
 /.idea/*
 !/.idea/runConfigurations

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "satrs",
     "satrs-mib",
     "satrs-example",
+    "satrs-minisim",
     "satrs-shared",
 ]
 

README.md

@@ -1,17 +1,24 @@
-<p align="center"> <img src="misc/satrs-logo.png" width="40%"> </p>
+<p align="center"> <img src="misc/satrs-logo-v2.png" width="40%"> </p>
 
+[![sat-rs website](https://img.shields.io/badge/sat--rs-website-darkgreen?style=flat)](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/)
+[![sat-rs book](https://img.shields.io/badge/sat--rs-book-darkgreen?style=flat)](https://absatsw.irs.uni-stuttgart.de/projects/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)
 
 sat-rs
 =========
 
-This is the repository of the sat-rs framework. Its primary goal is to provide re-usable components
+This is the repository of the sat-rs library. Its primary goal is to provide re-usable components
 to write on-board software for remote systems like rovers or satellites. It is specifically written
 for the special requirements for these systems. You can find an overview of the project and the
 link to the [more high-level sat-rs book](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/)
 at the [IRS software projects website](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/).
 
+This is early-stage software. Important features are missing. New releases
+with breaking changes are released regularly, with all changes documented inside respective
+changelog files. You should only use this library if your are willing to work in this
+environment.
+
 A lot of the architecture and general design considerations are based on the
 [FSFW](https://egit.irs.uni-stuttgart.de/fsfw/fsfw) C++ framework which has flight heritage
 through the 2 missions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)
@@ -33,7 +40,7 @@ This project currently contains following crates:
 * [`satrs-mib`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-mib):
    Components to build a mission information base from the on-board software directly.
 * [`satrs-example-stm32f3-disco`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example-stm32f3-disco):
-   Example of a simple example on-board software using sat-rs components on a bare-metal system
+   Example of a simple example using low-level sat-rs components on a bare-metal system
    with constrained resources.
 
 Each project has its own `CHANGELOG.md`.

coverage.py

@@ -18,15 +18,19 @@ def generate_cov_report(open_report: bool, format: str, package: str):
     out_path = "./target/debug/coverage"
     if format == "lcov":
         out_path = "./target/debug/lcov.info"
-    os.system(
+    grcov_cmd = (
         f"grcov . -s . --binary-path ./target/debug/ -t {format} --branch --ignore-not-existing "
         f"-o {out_path}"
     )
+    print(f"Running: {grcov_cmd}")
+    os.system(grcov_cmd)
     if format == "lcov":
-        os.system(
+        lcov_cmd = (
             "genhtml -o ./target/debug/coverage/ --show-details --highlight --ignore-errors source "
             "--legend ./target/debug/lcov.info"
         )
+        print(f"Running: {lcov_cmd}")
+        os.system(lcov_cmd)
     if open_report:
         coverage_report_path = os.path.abspath("./target/debug/coverage/index.html")
         webbrowser.open_new_tab(coverage_report_path)
@@ -43,7 +47,7 @@ def main():
     parser.add_argument(
         "-p",
         "--package",
-        choices=["satrs"],
+        choices=["satrs", "satrs-minisim", "satrs-example"],
         default="satrs",
         help="Choose project to generate coverage for",
     )

satrs-book/src/actions.md

@@ -15,7 +15,7 @@ action commanding could look like.
 2. Target ID and Action String based. The target ID is the same as in the first proposal, but
    the unique action is identified by a string.
 
-The framework provides an `ActionRequest` abstraction to model both of these cases.
+The library provides an `ActionRequest` abstraction to model both of these cases.
 
 ## Commanding with ECSS PUS 8
 

satrs-book/src/communication.md

@@ -17,10 +17,10 @@ it is still centered around small packets. `sat-rs` provides support for these E
 standards and also attempts to fill the gap to the internet protocol by providing the following
 components.
 
-1. [UDP TMTC Server](https://docs.rs/satrs/latest/satrs/hal/host/udp_server/index.html).
+1. [UDP TMTC Server](https://docs.rs/satrs/latest/satrs/hal/std/udp_server/index.html).
    UDP is already packet based which makes it an excellent fit for exchanging space packets.
 2. [TCP TMTC Server Components](https://docs.rs/satrs/latest/satrs/hal/std/tcp_server/index.html).
-   TCP is a stream based protocol, so the framework provides building blocks to parse telemetry
+   TCP is a stream based protocol, so the library provides building blocks to parse telemetry
    from an arbitrary bytestream. Two concrete implementations are provided:
     - [TCP spacepackets server](https://docs.rs/satrs/latest/satrs/hal/std/tcp_server/struct.TcpSpacepacketsServer.html)
       to parse tightly packed CCSDS Spacepackets.
@@ -39,8 +39,12 @@ task might be to store all arriving telemetry persistently. This is especially i
 space systems which do not have permanent contact like low-earth-orbit (LEO) satellites.
 
 The most important task of a TC source is to deliver the telecommands to the correct recipients.
-For modern component oriented software using message passing, this usually includes staged
-demultiplexing components to determine where a command needs to be sent.
+For component oriented software using message passing, this usually includes staged demultiplexing
+components to determine where a command needs to be sent.
+
+Using a generic concept of a TC source and a TM sink as part of the software design simplifies
+the flexibility of the TMTC infrastructure: Newly added TM generators and TC receiver only have to
+forward their generated or received packets to those handler objects.
 
 # Low-level protocols and the bridge to the communcation subsystem
 

satrs-book/src/design.md

@@ -1,13 +1,14 @@
-# Framework Design
+# Library Design
 
 Satellites and space systems in general are complex systems with a wide range of requirements for
-both the hardware and the software. Consequently, the general design of the framework is centered
+both the hardware and the software. Consequently, the general design of the library is centered
 around many light-weight components which try to impose as few restrictions as possible on how to
-solve certain problems.
+solve certain problems. This is also the reason why sat-rs is explicitely called a library
+instead of a framework.
 
 There are still a lot of common patterns and architectures across these systems where guidance
 of how to solve a problem and a common structure would still be extremely useful to avoid pitfalls
-which were already solved and to avoid boilerplate code. This framework tries to provide this
+which were already solved and to avoid boilerplate code. This library tries to provide this
 structure and guidance the following way:
 
 1. Providing this book which explains the architecture and design patterns in respect to common
@@ -18,7 +19,7 @@ structure and guidance the following way:
 3. Providing a good test suite. This includes both unittests and integration tests. The integration
    tests can also serve as smaller usage examples than the large `satrs-example` application.
 
-This framework has special support for standards used in the space industry. This especially
+This library has special support for standards used in the space industry. This especially
 includes standards provided by Consultative Committee for Space Data Systems (CCSDS) and European
 Cooperation for Space Standardization (ECSS). It does not enforce using any of those standards,
 but it is always recommended to use some sort of standard for interoperability.
@@ -30,10 +31,10 @@ Flying Laptop Project by the University of Stuttgart with Airbus Defence and Spa
 It has flight heritage through the 2 mssions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)
 and [EIVE](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/EIVE/).
 Therefore, a lot of the design concepts were ported more or less unchanged to the `sat-rs`
-framework.
+library.
 FLP is a medium-size small satellite with a higher budget and longer development time than EIVE,
 which allowed to build a highly reliable system while EIVE is a smaller 6U+ cubesat which had a
-shorter development cycle and was built using cheaper COTS components. This framework also tries
+shorter development cycle and was built using cheaper COTS components. This library also tries
 to accumulate the knowledge of developing the OBSW and operating the satellite for both these
 different systems and provide a solution for a wider range of small satellite systems.
 

satrs-book/src/example.md

@@ -1,6 +1,6 @@
 # sat-rs Example Application
 
-The `sat-rs` framework includes a monolithic example application which can be found inside
+The `sat-rs` library includes a monolithic example application which can be found inside
 the [`satrs-example`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example)
 subdirectory of the repository. The primary purpose of this example application is to show how
 the various components of the sat-rs framework could be used as part of a larger on-board

satrs-book/src/introduction.md

@@ -1,7 +1,7 @@
 The sat-rs book
 ======
 
-This book is the primary information resource for the [sat-rs framework](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
+This book is the primary information resource for the [sat-rs library](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
 in addition to the regular API documentation. It contains the following resources:
 
 1. Architecture informations and consideration which would exceeds the scope of the regular API.
@@ -12,10 +12,15 @@ in addition to the regular API documentation. It contains the following resource
 
 # Introduction
 
-The primary goal of the sat-rs framework is to provide re-usable components
+The primary goal of the sat-rs library is to provide re-usable components
 to write on-board software for remote systems like rovers or satellites. It is specifically written
 for the special requirements for these systems.
 
+It should be noted that sat-rs is early-stage software. Important features are missing. New releases
+with breaking changes are released regularly, with all changes documented inside respective
+changelog files. You should only use this library if your are willing to work in this
+environment.
+
 A lot of the architecture and general design considerations are based on the
 [FSFW](https://egit.irs.uni-stuttgart.de/fsfw/fsfw) C++ framework which has flight heritage
 through the 2 missions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)

satrs-book/src/modes-and-health.md

@@ -1,11 +1,11 @@
 # Modes
 
-Modes are an extremely useful concept for complex system in general. They also allow simplified
-system reasoning for both system operators and OBSW developers. They model the behaviour of a
-component and also provide observability of a system. A few examples of how to model
-different components of a space system with modes will be given.
+Modes are an extremely useful concept to model complex systems. They allow simplified
+system reasoning for both system operators and OBSW developers. They also provide a way to alter
+the behaviour of a component and also provide observability of a system. A few examples of how to
+model the mode of different components within a space system with modes will be given.
 
-## Modelling a pyhsical devices with modes
+## Pyhsical device component with modes
 
 The following simple mode scheme with the following three mode
 
@@ -13,7 +13,8 @@ The following simple mode scheme with the following three mode
 - `ON`
 - `NORMAL`
 
-can be applied to a large number of simpler devices of a remote system, for example sensors.
+can be applied to a large number of simpler device controllers of a remote system, for example
+sensors.
 
 1. `OFF` means that a device is physically switched off, and the corresponding software component
 does not poll the device regularly.
@@ -31,7 +32,7 @@ for the majority of devices:
 2. `NORMAL` or `ON` to `OFF`: Any important shutdown configuration or handling must be performed
    before powering off the device.
 
-## Modelling a controller with modes
+## Controller components with modes
 
 Controller components are not modelling physical devices, but a mode scheme is still the best
 way to model most of these components.

satrs-example-stm32f3-disco/.cargo/def_config.toml

@@ -0,0 +1,37 @@
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+# uncomment ONE of these three option to make `cargo run` start a GDB session
+# which option to pick depends on your system
+# You can also replace openocd.gdb by jlink.gdb when using a J-Link.
+# runner = "arm-none-eabi-gdb -q -x openocd.gdb"
+# runner = "gdb-multiarch -q -x openocd.gdb"
+# runner = "gdb -q -x openocd.gdb"
+runner = "probe-rs run --chip STM32F303VCTx"
+
+rustflags = [
+  "-C", "linker=flip-link",
+  # LLD (shipped with the Rust toolchain) is used as the default linker
+  "-C", "link-arg=-Tlink.x",
+  "-C", "link-arg=-Tdefmt.x",
+
+  # This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x
+  # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
+  "-C", "link-arg=--nmagic",
+
+  # if you run into problems with LLD switch to the GNU linker by commenting out
+  # this line
+  # "-C", "linker=arm-none-eabi-ld",
+
+  # if you need to link to pre-compiled C libraries provided by a C toolchain
+  # use GCC as the linker by commenting out both lines above and then
+  # uncommenting the three lines below
+  # "-C", "linker=arm-none-eabi-gcc",
+  # "-C", "link-arg=-Wl,-Tlink.x",
+  # "-C", "link-arg=-nostartfiles",
+]
+
+[build]
+# comment out the following line if you intend to run unit tests on host machine
+target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
+
+[env]
+DEFMT_LOG = "info"

satrs-example-stm32f3-disco/.gitignore

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

satrs-example-stm32f3-disco/.vscode/launch.json

@@ -1,66 +0,0 @@
-{
-    /* 
-     * Requires the Rust Language Server (RLS) and Cortex-Debug extensions
-     * https://marketplace.visualstudio.com/items?itemName=rust-lang.rust
-     * https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug
-     */
-    "version": "0.2.0",
-    "configurations": [
-        {
-            /* Launches debug session for currently open example */
-            "type": "cortex-debug",
-            "request": "launch",
-            "name": "Debug",
-            "servertype": "openocd",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "cargo build",
-            "runToEntryPoint": "true",
-            "executable": "./target/thumbv7em-none-eabihf/debug/satrs-example-stm32f3-disco",
-            "preLaunchCommands": ["break rust_begin_unwind"],
-            "device": "STM32F303VCT6",
-            "configFiles": [
-                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
-                "interface/stlink.cfg",
-                "target/stm32f3x.cfg"
-            ],
-            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
-            "swoConfig": {
-                "enabled": true,
-                "cpuFrequency": 8000000,
-                "swoFrequency": 2000000,
-                "source": "probe",
-                "decoders": [
-                    { "type": "console", "label": "ITM", "port": 0 }
-                ]
-            }
-        },
-        {
-            /* Launches debug session for currently open example */
-            "type": "cortex-debug",
-            "request": "launch",
-            "name": "Release",
-            "servertype": "openocd",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "cargo build",
-            "runToEntryPoint": "true",
-            "executable": "./target/thumbv7em-none-eabihf/release/satrs-example-stm32f3-disco",
-            "preLaunchCommands": ["break rust_begin_unwind"],
-            "device": "STM32F303VCT6",
-            "configFiles": [
-                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
-                "interface/stlink.cfg",
-                "target/stm32f3x.cfg"
-            ],
-            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
-            "swoConfig": {
-                "enabled": true,
-                "cpuFrequency": 8000000,
-                "swoFrequency": 2000000,
-                "source": "probe",
-                "decoders": [
-                    { "type": "console", "label": "ITM", "port": 0 }
-                ]
-            }
-        }
-    ]
-}

satrs-example-stm32f3-disco/.vscode/settings_default.json

@@ -1,3 +0,0 @@
-{
-    "cortex-debug.gdbPath.linux": "gdb-multiarch"
-}

satrs-example-stm32f3-disco/Cargo.lock

@@ -13,18 +13,18 @@ dependencies = [
 
 [[package]]
 name = "atomic-polyfill"
-version = "0.1.11"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3ff7eb3f316534d83a8a2c3d1674ace8a5a71198eba31e2e2b597833f699b28"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
 dependencies = [
  "critical-section",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
 
 [[package]]
 name = "bare-metal"
@@ -55,20 +55,21 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bxcan"
-version = "0.6.2"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b13b4b2ea9ab2ba924063ebb86ad895cb79f4a79bf90f27949eb20c335b30f9"
+checksum = "40ac3d0c0a542d0ab5521211f873f62706a7136df415676f676d347e5a41dd80"
 dependencies = [
  "bitflags",
- "nb 1.0.0",
+ "embedded-hal 0.2.7",
+ "nb 1.1.0",
  "vcell",
 ]
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cast"
@@ -87,31 +88,36 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.23"
+version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
- "num-integer",
  "num-traits",
 ]
 
+[[package]]
+name = "cobs"
+version = "0.2.3"
+source = "git+https://github.com/robamu/cobs.rs.git?branch=all_features#c70a7f30fd00a7cbdb7666dec12b437977385d40"
+
 [[package]]
 name = "cortex-m"
-version = "0.7.6"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70858629a458fdfd39f9675c4dc309411f2a3f83bede76988d81bf1a0ecee9e0"
+checksum = "8ec610d8f49840a5b376c69663b6369e71f4b34484b9b2eb29fb918d92516cb9"
 dependencies = [
  "bare-metal 0.2.5",
  "bitfield",
- "embedded-hal",
+ "critical-section",
+ "embedded-hal 0.2.7",
  "volatile-register",
 ]
 
 [[package]]
 name = "cortex-m-rt"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6d3328b8b5534f0c90acd66b68950f2763b37e0173cac4d8b4937c4a80761f9"
+checksum = "ee84e813d593101b1723e13ec38b6ab6abbdbaaa4546553f5395ed274079ddb1"
 dependencies = [
  "cortex-m-rt-macros",
 ]
@@ -124,48 +130,44 @@ checksum = "f0f6f3e36f203cfedbc78b357fb28730aa2c6dc1ab060ee5c2405e843988d3c7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cortex-m-rtic"
-version = "1.1.3"
+name = "cortex-m-semihosting"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6b82f1c39acd6c3a35c2013b6110c20f5bc534522791fabadeed49ccada2dce"
+checksum = "c23234600452033cc77e4b761e740e02d2c4168e11dbf36ab14a0f58973592b0"
 dependencies = [
- "bare-metal 1.0.0",
  "cortex-m",
- "cortex-m-rtic-macros",
- "heapless",
- "rtic-core",
- "rtic-monotonic",
- "version_check",
 ]
 
 [[package]]
-name = "cortex-m-rtic-macros"
-version = "1.1.5"
+name = "crc"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e8e9645ef54bec1cf70ac33e9bf9566e6507ab5b41ae6baf3735662194e8607"
+checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe"
 dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "rtic-syntax",
- "syn",
+ "crc-catalog",
 ]
 
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
 [[package]]
 name = "critical-section"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6548a0ad5d2549e111e1f6a11a6c2e2d00ce6a3dafe22948d67c2b443f775e52"
+checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
 
 [[package]]
 name = "darling"
-version = "0.14.2"
+version = "0.20.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0dd3cd20dc6b5a876612a6e5accfe7f3dd883db6d07acfbf14c128f61550dfa"
+checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -173,26 +175,102 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.14.2"
+version = "0.20.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a784d2ccaf7c98501746bf0be29b2022ba41fd62a2e622af997a03e9f972859f"
+checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.14.2"
+version = "0.20.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7618812407e9402654622dd402b0a89dff9ba93badd6540781526117b92aab7e"
+checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
 dependencies = [
  "darling_core",
  "quote",
- "syn",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "defmt"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3939552907426de152b3c2c6f51ed53f98f448babd26f28694c95f5906194595"
+dependencies = [
+ "bitflags",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-brtt"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2f0ac3635d0c89d12b8101fcb44a7625f5f030a1c0491124b74467eb5a58a78"
+dependencies = [
+ "critical-section",
+ "defmt",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18bdc7a7b92ac413e19e95240e75d3a73a8d8e78aa24a594c22cbb4d44b4bbda"
+dependencies = [
+ "defmt-parser",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff4a5fefe330e8d7f31b16a318f9ce81000d8e35e69b93eae154d16d2278f70f"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "defmt-test"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290966e8c38f94b11884877242de876280d0eab934900e9642d58868e77c5df1"
+dependencies = [
+ "cortex-m-rt",
+ "cortex-m-semihosting",
+ "defmt",
+ "defmt-test-macros",
+]
+
+[[package]]
+name = "defmt-test-macros"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "984bc6eca246389726ac2826acc2488ca0fe5fcd6b8d9b48797021951d76a125"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "delegate"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ee5df75c70b95bd3aacc8e2fd098797692fb1d54121019c4de481e42f04c8a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -214,6 +292,12 @@ dependencies = [
  "void",
 ]
 
+[[package]]
+name = "embedded-hal"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "361a90feb7004eca4019fb28352a9465666b24f840f5c3cddf0ff13920590b89"
+
 [[package]]
 name = "embedded-time"
 version = "0.12.1"
@@ -225,25 +309,31 @@ dependencies = [
 
 [[package]]
 name = "enumset"
-version = "1.0.12"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19be8061a06ab6f3a6cf21106c873578bf01bd42ad15e0311a9c76161cb1c753"
+checksum = "226c0da7462c13fb57e5cc9e0dc8f0635e7d27f276a3a7fd30054647f669007d"
 dependencies = [
  "enumset_derive",
 ]
 
 [[package]]
 name = "enumset_derive"
-version = "0.6.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03e7b551eba279bf0fa88b83a46330168c1560a52a94f5126f892f0b364ab3e0"
+checksum = "e08b6c6ab82d70f08844964ba10c7babb716de2ecaeab9be5717918a5177d3af"
 dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.58",
 ]
 
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -252,18 +342,42 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "fugit"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab17bb279def6720d058cb6c052249938e7f99260ab534879281a95367a87e5"
+checksum = "17186ad64927d5ac8f02c1e77ccefa08ccd9eaa314d5a4772278aa204a22f7e7"
 dependencies = [
  "gcd",
 ]
 
 [[package]]
-name = "gcd"
-version = "2.2.0"
+name = "futures-core"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4b1b088ad0a967aa29540456b82fc8903f854775d33f71e9709c4efb3dfbfd2"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+
+[[package]]
+name = "futures-task"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+
+[[package]]
+name = "futures-util"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+]
+
+[[package]]
+name = "gcd"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a"
 
 [[package]]
 name = "generic-array"
@@ -276,9 +390,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.6"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -286,29 +400,26 @@ dependencies = [
 
 [[package]]
 name = "hash32"
-version = "0.2.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606"
 dependencies = [
  "byteorder",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 
 [[package]]
 name = "heapless"
-version = "0.7.16"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db04bc24a18b9ea980628ecf00e6c0264f3c1426dac36c00cb49b6fbad8b0743"
+checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
 dependencies = [
- "atomic-polyfill",
  "hash32",
- "rustc_version 0.4.0",
- "spin",
  "stable_deref_trait",
 ]
 
@@ -320,41 +431,14 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
 name = "indexmap"
-version = "1.9.2"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
- "autocfg",
+ "equivalent",
  "hashbrown",
 ]
 
-[[package]]
-name = "itm_logger"
-version = "0.1.3-pre.0"
-dependencies = [
- "cortex-m",
- "log",
-]
-
-[[package]]
-name = "lock_api"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
-
 [[package]]
 name = "lsm303dlhc"
 version = "0.2.0"
@@ -362,7 +446,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5d1a5c290951321d1b0d4a40edd828537de9889134a0e67c5146542ae57706"
 dependencies = [
  "cast",
- "embedded-hal",
+ "embedded-hal 0.2.7",
  "generic-array 0.11.2",
 ]
 
@@ -372,7 +456,7 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc4010833aea396656c2f91ee704d51a6f1329ec2ab56ffd00bfd56f7481ea94"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -381,14 +465,14 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
 dependencies = [
- "nb 1.0.0",
+ "nb 1.1.0",
 ]
 
 [[package]]
 name = "nb"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
+checksum = "8d5439c4ad607c3c23abf66de8c8bf57ba8adcd1f129e699851a6e43935d339d"
 
 [[package]]
 name = "num"
@@ -414,19 +498,18 @@ dependencies = [
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
 [[package]]
 name = "num-iter"
-version = "0.1.43"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -446,27 +529,60 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
-name = "panic-itm"
-version = "0.4.2"
+name = "num_enum"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d577d97d1b31268087b6dddf2470e6794ef5eee87d9dca7fcd0481695391a4c"
+checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "panic-probe"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa6fa5645ef5a760cd340eaa92af9c1ce131c8c09e7f8926d8a24b59d26652b9"
 dependencies = [
  "cortex-m",
+ "defmt",
 ]
 
 [[package]]
 name = "paste"
-version = "1.0.11"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "proc-macro-error"
@@ -477,7 +593,7 @@ dependencies = [
  "proc-macro-error-attr",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 1.0.109",
  "version_check",
 ]
 
@@ -494,31 +610,54 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.49"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57a8eca9f9c4ffde41714334dee777596264c7825420f521abc92b5b5deb63a5"
+checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.23"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "rtcc"
-version = "0.3.0"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3623619ce77c09a7d87cf7c61c5c887b9c7dee8805f66af6c4aa5824be4d9930"
+checksum = "95973c3a0274adc4f3c5b70d2b5b85618d6de9559a6737d3293ecae9a2fc0839"
 dependencies = [
  "chrono",
 ]
 
+[[package]]
+name = "rtic"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c443db16326376bdd64377da268f6616d5f804aba8ce799bac7d1f7f244e9d51"
+dependencies = [
+ "atomic-polyfill",
+ "bare-metal 1.0.0",
+ "cortex-m",
+ "critical-section",
+ "rtic-core",
+ "rtic-macros",
+]
+
+[[package]]
+name = "rtic-common"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0786b50b81ef9d2a944a000f60405bb28bf30cd45da2d182f3fe636b2321f35c"
+dependencies = [
+ "critical-section",
+]
+
 [[package]]
 name = "rtic-core"
 version = "1.0.0"
@@ -526,21 +665,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9369355b04d06a3780ec0f51ea2d225624db777acbc60abd8ca4832da5c1a42"
 
 [[package]]
-name = "rtic-monotonic"
-version = "1.0.0"
+name = "rtic-macros"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb8b0b822d1a366470b9cea83a1d4e788392db763539dc4ba022bcc787fece82"
-
-[[package]]
-name = "rtic-syntax"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ad3ae243dd8d0a1b064615f664d4fa7e63929939074c564cbe5efdc4c503065"
+checksum = "54053598ea24b1b74937724e366558412a1777eb2680b91ef646db540982789a"
 dependencies = [
  "indexmap",
+ "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "rtic-monotonics"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058c2397dbd5bb4c5650a0e368c3920953e458805ff5097a0511b8147b3619d7"
+dependencies = [
+ "atomic-polyfill",
+ "cfg-if",
+ "cortex-m",
+ "embedded-hal 1.0.0",
+ "fugit",
+ "rtic-time",
+]
+
+[[package]]
+name = "rtic-time"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b232e7aebc045cfea81cdd164bc2727a10aca9a4568d406d0a5661cdfd0f19"
+dependencies = [
+ "critical-section",
+ "futures-util",
+ "rtic-common",
 ]
 
 [[package]]
@@ -558,31 +717,52 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "semver 1.0.16",
+ "semver 1.0.22",
 ]
 
 [[package]]
-name = "sat-rs-example-stm32f-disco"
+name = "satrs"
+version = "0.2.0-rc.0"
+dependencies = [
+ "cobs",
+ "crc",
+ "delegate",
+ "num-traits",
+ "num_enum",
+ "paste",
+ "satrs-shared",
+ "smallvec",
+ "spacepackets",
+]
+
+[[package]]
+name = "satrs-example-stm32f3-disco"
 version = "0.1.0"
 dependencies = [
+ "cobs",
  "cortex-m",
  "cortex-m-rt",
- "cortex-m-rtic",
- "embedded-hal",
+ "cortex-m-semihosting",
+ "defmt",
+ "defmt-brtt",
+ "defmt-test",
+ "embedded-hal 0.2.7",
  "enumset",
  "heapless",
- "itm_logger",
- "panic-itm",
+ "panic-probe",
+ "rtic",
+ "rtic-monotonics",
+ "satrs",
  "stm32f3-discovery",
  "stm32f3xx-hal",
- "systick-monotonic",
 ]
 
 [[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+name = "satrs-shared"
+version = "0.1.3"
+dependencies = [
+ "spacepackets",
+]
 
 [[package]]
 name = "semver"
@@ -595,9 +775,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.16"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
+checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
 
 [[package]]
 name = "semver-parser"
@@ -607,17 +787,28 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "slice-group-by"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b634d87b960ab1a38c4fe143b508576f075e7c978bfad18217645ebfdfa2ec"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
 
 [[package]]
-name = "spin"
-version = "0.9.4"
+name = "smallvec"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "spacepackets"
+version = "0.11.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2cfd5f9a4c7f10714d21f9bc61f2d176cb7ae092cdd687e7ade2d4e6f7d7125"
 dependencies = [
- "lock_api",
+ "crc",
+ "defmt",
+ "delegate",
+ "num-traits",
+ "num_enum",
+ "zerocopy",
 ]
 
 [[package]]
@@ -639,9 +830,9 @@ dependencies = [
 
 [[package]]
 name = "stm32f3"
-version = "0.14.0"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "265cda62ac13307414de4aca58dbbbd8038ddba85cffbb335823aa216f2e3200"
+checksum = "b28b37228ef3fa47956af38c6abd756e912f244c1657f14e66d42fc8d74ea96f"
 dependencies = [
  "bare-metal 1.0.0",
  "cortex-m",
@@ -651,7 +842,8 @@ dependencies = [
 
 [[package]]
 name = "stm32f3-discovery"
-version = "0.8.0-pre.0"
+version = "0.8.0-alpha.0"
+source = "git+https://github.com/robamu/stm32f3-discovery?branch=complete-dma-update-hal#5ccacae07ceff02d7d3649df67a6a0ba2a144752"
 dependencies = [
  "accelerometer",
  "cortex-m",
@@ -663,20 +855,20 @@ dependencies = [
 
 [[package]]
 name = "stm32f3xx-hal"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e422c5c044e8f3a068b1e14b83c071449e27c9d4bc0e24f972b552d79f2be03"
+version = "0.11.0-alpha.0"
+source = "git+https://github.com/robamu/stm32f3xx-hal?branch=complete-dma-update#04fc76b7912649c84b57bd0ab803ea3ccf2aadae"
 dependencies = [
- "bare-metal 1.0.0",
  "bxcan",
  "cfg-if",
  "cortex-m",
  "cortex-m-rt",
+ "critical-section",
  "embedded-dma",
- "embedded-hal",
+ "embedded-hal 0.2.7",
  "embedded-time",
  "enumset",
- "nb 1.0.0",
+ "nb 1.1.0",
+ "num-traits",
  "paste",
  "rtcc",
  "slice-group-by",
@@ -691,14 +883,14 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90a4adc8cbd1726249b161898e48e0f3f1ce74d34dc784cbbc98fba4ed283fbf"
 dependencies = [
- "embedded-hal",
+ "embedded-hal 0.2.7",
 ]
 
 [[package]]
 name = "syn"
-version = "1.0.107"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -706,27 +898,47 @@ dependencies = [
 ]
 
 [[package]]
-name = "systick-monotonic"
-version = "1.0.1"
+name = "syn"
+version = "2.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fb822d5c615a0ae3a4795ee5b1d06381c7faf488d861c0a4fa8e6a88d5ff84"
+checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
 dependencies = [
- "cortex-m",
- "fugit",
- "rtic-monotonic",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "typenum"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.6"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "usb-device"
@@ -754,9 +966,30 @@ checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
 
 [[package]]
 name = "volatile-register"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ee8f19f9d74293faf70901bc20ad067dc1ad390d2cbf1e3f75f721ffee908b6"
+checksum = "de437e2a6208b014ab52972a27e59b33fa2920d3e00fe05026167a1c509d19cc"
 dependencies = [
  "vcell",
 ]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]

satrs-example-stm32f3-disco/Cargo.toml

@@ -2,58 +2,82 @@
 name = "satrs-example-stm32f3-disco"
 version = "0.1.0"
 edition = "2021"
+default-run = "satrs-example-stm32f3-disco"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cortex-m = "0.7"
+cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-embedded-hal = "0.2.6"
-cortex-m-rtic = "1.0"
-enumset = "1.0"
-heapless = "0.7"
-systick-monotonic = "1.0"
+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"
+enumset = "1"
+heapless = "0.8"
+
+[dependencies.rtic]
+version = "2"
+features = ["thumbv7-backend"]
+
+[dependencies.rtic-monotonics]
+version = "1"
+features = ["cortex-m-systick"]
 
 [dependencies.cobs]
 git = "https://github.com/robamu/cobs.rs.git"
 branch = "all_features"
 default-features = false
 
-[dependencies.panic-itm]
-version = "0.4"
-
-[dependencies.itm_logger]
-git = "https://github.com/robamu/itm_logger.rs.git"
-branch = "all_features"
-version = "0.1.3-alpha.0"
-
 [dependencies.stm32f3xx-hal]
 git = "https://github.com/robamu/stm32f3xx-hal"
-version = "0.10.0-alpha.0"
+version = "0.11.0-alpha.0"
 features = ["stm32f303xc", "rt", "enumset"]
-branch = "all_features"
+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 = "all_features"
+branch = "complete-dma-update-hal"
 # Can be used in workspace to develop and update BSP
 # path = "../stm32f3-discovery"
 
-[dependencies.satrs-core]
-git = "https://egit.irs.uni-stuttgart.de/rust/satrs-core.git"
-version = "0.1.0-alpha.0"
+[dependencies.satrs]
+path = "../satrs"
 default-features = false
+features = ["defmt"]
 
-# this lets you use `cargo fix`!
-# [[bin]]
-# name = "stm32f3-blinky"
-# test = false
-# bench = false
+[dev-dependencies]
+defmt-test = "0.3"
 
+# cargo test
+[profile.test]
+codegen-units = 1
+debug = 2
+debug-assertions = true # <-
+incremental = false
+opt-level = "s" # <-
+overflow-checks = true # <-
+
+# cargo build/run --release
 [profile.release]
-codegen-units = 1 # better optimizations
-debug = true # symbols are nice and they don't increase the size on Flash
-lto = true # better optimizations
+codegen-units = 1
+debug = 2
+debug-assertions = false # <-
+incremental = false
+lto = 'fat'
+opt-level = "s" # <-
+overflow-checks = false # <-
+
+# cargo test --release
+[profile.bench]
+codegen-units = 1
+debug = 2
+debug-assertions = false # <-
+incremental = false
+lto = 'fat'
+opt-level = "s" # <-
+overflow-checks = false # <-

satrs-example-stm32f3-disco/README.md

@@ -2,15 +2,25 @@ sat-rs example for the STM32F3-Discovery board
 =======
 
 This example application shows how the [sat-rs framework](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad)
-can be used on an embedded target. It also shows how a relatively simple OBSW could be built when no
-standard runtime is available. It uses [RTIC](https://rtic.rs/1/book/en/) as the concurrency
-framework.
+can be used on an embedded target.
+It also shows how a relatively simple OBSW could be built when no standard runtime is available.
+It uses [RTIC](https://rtic.rs/1/book/en/) as the concurrency framework and the
+[defmt](https://defmt.ferrous-systems.com/) framework for logging.
 
 The STM32F3-Discovery device was picked because it is a cheap Cortex-M4 based device which is also
 used by the [Rust Embedded Book](https://docs.rust-embedded.org/book/intro/hardware.html) and the
 [Rust Discovery](https://docs.rust-embedded.org/discovery/f3discovery/) book as an introduction
 to embedded Rust.
 
+## Pre-Requisites
+
+Make sure the following tools are installed:
+
+1. [`probe-rs`](https://probe.rs/): Application used to flash and debug the MCU.
+2. Optional and recommended: [VS Code](https://code.visualstudio.com/) with
+   [probe-rs plugin](https://marketplace.visualstudio.com/items?itemName=probe-rs.probe-rs-debugger)
+   for debugging.
+
 ## Preparing Rust and the repository
 
 Building an application requires the `thumbv7em-none-eabihf` cross-compiler toolchain.
@@ -40,15 +50,23 @@ you can simply build the application with
 cargo build
 ```
 
-## Flashing and Debugging from the command line
+## Flashing from the command line
 
-TODO
+You can flash the application from the command line using `probe-rs`:
+
+```sh
+probe-rs run --chip STM32F303VCTx
+```
 
 ## Debugging with VS Code
 
 The STM32F3-Discovery comes with an on-board ST-Link so all that is required to flash and debug
-the board is a Mini-USB cable. The code in this repository was debugged using `openocd`
-and the VS Code [`Cortex-Debug` plugin](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug).
+the board is a Mini-USB cable. The code in this repository was debugged using [`probe-rs`](https://probe.rs/docs/tools/debuggerA)
+and the VS Code [`probe-rs` plugin](https://marketplace.visualstudio.com/items?itemName=probe-rs.probe-rs-debugger).
+Make sure to install this plugin first.
+
+Sample configuration files are provided inside the `vscode` folder.
+Use `cp vscode .vscode -r` to use them for your project.
 
 Some sample configuration files for VS Code were provided as well. You can simply use `Run` and `Debug`
 to automatically rebuild and flash your application.
@@ -56,20 +74,41 @@ to automatically rebuild and flash your application.
 The `tasks.json` and `launch.json` files are generic and you can use them immediately by opening
 the folder in VS code or adding it to a workspace.
 
-If you would like to use a custom GDB application, you can specify the gdb binary in the following
-configuration variables in your `settings.json`:
-
-- `"cortex-debug.gdbPath"`
-- `"cortex-debug.gdbPath.linux"`
-- `"cortex-debug.gdbPath.windows"`
-- `"cortex-debug.gdbPath.osx"`
-
 ## Commanding with Python
 
 When the SW is running on the Discovery board, you can command the MCU via a serial interface,
-using COBS encoded CCSDS packets.
+using COBS encoded PUS packets.
 
-TODO:
-  - How and where to connect serial interface on the MCU
-  - How to set up Python venv (or at least strongly recommend it) and install deps
-  - How to copy `def_tmtc_conf.json` to `tmtc_conf.json` and adapt it for custom serial port
+It is recommended to use a virtual environment to do this. To set up one in the command line,
+you can use `python3 -m venv venv` on Unix systems or `py -m venv venv` on Windows systems.
+After doing this, you can check the [venv tutorial](https://docs.python.org/3/tutorial/venv.html)
+on how to activate the environment and then use the following command to install the required
+dependency:
+
+```sh
+pip install -r requirements.txt
+```
+
+The packets are exchanged using a dedicated serial interface. You can use any generic USB-to-UART
+converter device with the TX pin connected to the PA3 pin and the RX pin connected to the PA2 pin.
+
+A default configuration file for the python application is provided and can be used by running
+
+```sh
+cp def_tmtc_conf.json tmtc_conf.json
+```
+
+After that, you can for example send a ping to the MCU using the following command
+
+```sh
+./main.py -p /ping
+```
+
+You can configure the blinky frequency using
+
+```sh
+./main.py -p /change_blink_freq
+```
+
+All these commands will package a PUS telecommand which will be sent to the MCU using the COBS
+format as the packet framing format.

satrs-example-stm32f3-disco/build.rs

@@ -1,18 +0,0 @@
-use std::env;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-
-fn main() {
-    // Put the linker script somewhere the linker can find it
-    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    File::create(out.join("memory.x"))
-        .unwrap()
-        .write_all(include_bytes!("memory.x"))
-        .unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-
-    // Only re-run the build script when memory.x is changed,
-    // instead of when any part of the source code changes.
-    println!("cargo:rerun-if-changed=memory.x");
-}

satrs-example-stm32f3-disco/legacy/openocd.gdb

@@ -24,7 +24,9 @@ break main
 # # 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
-monitor tpiu config internal itm.txt uart off 8000000
+# # 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
@@ -32,7 +34,7 @@ monitor tpiu config internal itm.txt uart off 8000000
 # monitor tpiu config external uart off 8000000 2000000
 
 # # enable ITM port 0
-monitor itm port 0 on
+# monitor itm port 0 on
 
 load
 

satrs-example-stm32f3-disco/pyclient/.gitignore

@@ -1,4 +1,5 @@
 /venv
+/.tmtc-history.txt
 /log
 /.idea/*
 !/.idea/runConfigurations

satrs-example-stm32f3-disco/pyclient/main.py

@@ -1,39 +1,40 @@
 #!/usr/bin/env python3
 """Example client for the sat-rs example application"""
-import enum
 import struct
+import logging
 import sys
 import time
-from typing import Optional, cast
+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, PusVerificator
 from spacepackets.ecss.pus_17_test import Service17Tm
 from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
 
-from tmtccmd import CcsdsTmtcBackend, TcHandlerBase, ProcedureParamsWrapper
+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.tm import CcsdsTmHandler, SpecificApidHandlerBase
-from tmtccmd.com_if import ComInterface
+from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.com import ComInterface
 from tmtccmd.config import (
+    CmdTreeNode,
     default_json_path,
     SetupParams,
-    TmTcCfgHookBase,
-    TmtcDefinitionWrapper,
-    CoreServiceList,
-    OpCodeEntry,
+    HookBase,
     params_to_procedure_conversion,
 )
-from tmtccmd.config.com_if import SerialCfgWrapper
+from tmtccmd.config.com import SerialCfgWrapper
 from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
-from tmtccmd.logging import get_console_logger
 from tmtccmd.logging.pus import (
     RegularTmtcLogWrapper,
     RawTmtcTimedLogWrapper,
     TimedLogWhen,
 )
-from tmtccmd.tc import (
+from tmtccmd.tmtc import (
     TcQueueEntryType,
     ProcedureWrapper,
     TcProcedureType,
@@ -41,27 +42,26 @@ from tmtccmd.tc import (
     SendCbParams,
     DefaultPusQueueHelper,
 )
-from tmtccmd.tm.pus_5_event import Service5Tm
+from tmtccmd.pus.s5_fsfw_event import Service5Tm
 from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
 from tmtccmd.util.obj_id import ObjectIdDictT
 
-from tmtccmd.util.tmtc_printer import FsfwTmTcPrinter
-
-LOGGER = get_console_logger()
+_LOGGER = logging.getLogger()
 
 EXAMPLE_PUS_APID = 0x02
 
 
-class SatRsConfigHook(TmTcCfgHookBase):
+class SatRsConfigHook(HookBase):
     def __init__(self, json_cfg_path: str):
         super().__init__(json_cfg_path=json_cfg_path)
 
-    def assign_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
-        from tmtccmd.config.com_if import (
+    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,
@@ -76,35 +76,14 @@ class SatRsConfigHook(TmTcCfgHookBase):
             cfg.serial_cfg.serial_timeout = 0.5
         return create_com_interface_default(cfg)
 
-    def get_tmtc_definitions(self) -> TmtcDefinitionWrapper:
-        from tmtccmd.config.globals import get_default_tmtc_defs
+    def get_command_definitions(self) -> CmdTreeNode:
+        """This function should return the root node of the command definition tree."""
+        return create_cmd_definition_tree()
 
-        defs = get_default_tmtc_defs()
-        srv_5 = OpCodeEntry()
-        srv_5.add("0", "Event Test")
-        defs.add_service(
-            name=CoreServiceList.SERVICE_5.value,
-            info="PUS Service 5 Event",
-            op_code_entry=srv_5,
-        )
-        srv_17 = OpCodeEntry()
-        srv_17.add("0", "Ping Test")
-        defs.add_service(
-            name=CoreServiceList.SERVICE_17_ALT,
-            info="PUS Service 17 Test",
-            op_code_entry=srv_17,
-        )
-        srv_3 = OpCodeEntry()
-        defs.add_service(
-            name=CoreServiceList.SERVICE_3,
-            info="PUS Service 3 Housekeeping",
-            op_code_entry=srv_3,
-        )
-        return defs
-
-    def perform_mode_operation(self, tmtc_backend: CcsdsTmtcBackend, mode: int):
-        LOGGER.info("Mode operation hook was called")
-        pass
+    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
@@ -112,74 +91,76 @@ class SatRsConfigHook(TmTcCfgHookBase):
         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,
-        printer: FsfwTmTcPrinter,
         raw_logger: RawTmtcTimedLogWrapper,
     ):
         super().__init__(EXAMPLE_PUS_APID, None)
-        self.printer = printer
+        self.file_logger = file_logger
         self.raw_logger = raw_logger
         self.verif_wrapper = verif_wrapper
 
-    def handle_tm(self, packet: bytes, _user_args: any):
+    def handle_tm(self, packet: bytes, _user_args: Any):
+        time_reader = CdsShortTimestamp.empty()
         try:
-            tm_packet = PusTelemetry.unpack(packet)
+            pus_tm = PusTelemetry.unpack(packet, time_reader=CdsShortTimestamp.empty())
         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}")
+            _LOGGER.warning("Could not generate PUS TM object from raw data")
+            _LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
             raise e
-        service = tm_packet.service
-        dedicated_handler = False
+        service = pus_tm.service
+        tm_packet = None
         if service == 1:
-            tm_packet = Service1Tm.unpack(data=packet, params=UnpackParams(1, 2))
+            tm_packet = Service1Tm.unpack(
+                data=packet, params=UnpackParams(time_reader, 1, 2)
+            )
             res = self.verif_wrapper.add_tm(tm_packet)
             if res is None:
-                LOGGER.info(
+                _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(
+                _LOGGER.warning(
                     f"No matching telecommand found for {tm_packet.tc_req_id}"
                 )
             else:
                 self.verif_wrapper.log_to_console(tm_packet, res)
                 self.verif_wrapper.log_to_file(tm_packet, res)
-            dedicated_handler = True
         if service == 3:
-            LOGGER.info("No handling for HK packets implemented")
-            LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
-            pus_tm = PusTelemetry.unpack(packet)
+            _LOGGER.info("No handling for HK packets implemented")
+            _LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
+            pus_tm = PusTelemetry.unpack(packet, CdsShortTimestamp.empty())
             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:]
-            dedicated_handler = True
+                _LOGGER.info("received JSON string: " + json_str.decode("utf-8"))
         if service == 5:
-            tm_packet = Service5Tm.unpack(packet)
+            tm_packet = Service5Tm.unpack(packet, time_reader)
         if service == 17:
-            tm_packet = Service17Tm.unpack(packet)
-            dedicated_handler = True
+            tm_packet = Service17Tm.unpack(packet, time_reader)
             if tm_packet.subservice == 2:
-                self.printer.file_logger.info("Received Ping Reply TM[17,2]")
-                LOGGER.info("Received Ping Reply TM[17,2]")
+                _LOGGER.info("Received Ping Reply TM[17,2]")
             else:
-                self.printer.file_logger.info(
-                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
-                )
-                LOGGER.info(
+                _LOGGER.info(
                     f"Received Test Packet with unknown subservice {tm_packet.subservice}"
                 )
         if tm_packet is None:
-            LOGGER.info(
+            _LOGGER.info(
                 f"The service {service} is not implemented in Telemetry Factory"
             )
-            tm_packet = PusTelemetry.unpack(packet)
-        self.raw_logger.log_tm(tm_packet)
-        if not dedicated_handler and tm_packet is not None:
-            self.printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
+            tm_packet = PusTelemetry.unpack(packet, time_reader)
+        self.raw_logger.log_tm(pus_tm)
 
 
 def make_addressable_id(target_id: int, unique_id: int) -> bytes:
@@ -198,8 +179,11 @@ class TcHandler(TcHandlerBase):
         self.seq_count_provider = seq_count_provider
         self.verif_wrapper = verif_wrapper
         self.queue_helper = DefaultPusQueueHelper(
-            queue_wrapper=None,
+            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):
@@ -212,61 +196,74 @@ class TcHandler(TcHandlerBase):
                 )
                 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}")
+                _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)
+            _LOGGER.info(log_entry.log_str)
 
-    def queue_finished_cb(self, helper: ProcedureWrapper):
-        if helper.proc_type == TcProcedureType.DEFAULT:
-            def_proc = helper.to_def_procedure()
-            LOGGER.info(
-                f"Queue handling finished for service {def_proc.service} and "
-                f"op code {def_proc.op_code}"
-            )
+    def queue_finished_cb(self, info: ProcedureWrapper):
+        if info.proc_type == TcProcedureType.DEFAULT:
+            def_proc = info.to_def_procedure()
+            _LOGGER.info(f"Queue handling finished for command {def_proc.cmd_path}")
 
-    def feed_cb(self, helper: ProcedureWrapper, wrapper: FeedWrapper):
+    def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
         q = self.queue_helper
         q.queue_wrapper = wrapper.queue_wrapper
-        if helper.proc_type == TcProcedureType.DEFAULT:
-            def_proc = helper.to_def_procedure()
-            service = def_proc.service
-            op_code = def_proc.op_code
-            if (
-                service == CoreServiceList.SERVICE_17
-                or service == CoreServiceList.SERVICE_17_ALT
-            ):
+        if info.proc_type == TcProcedureType.DEFAULT:
+            def_proc = info.to_def_procedure()
+            cmd_path = def_proc.cmd_path
+            if cmd_path == "/ping":
                 q.add_log_cmd("Sending PUS ping telecommand")
-                return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
+                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()
-    post_args_wrapper = parser_wrapper.parse(hook_obj)
     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(params, proc_wrapper)
+        post_args_wrapper.set_params_without_prompts(proc_wrapper)
     else:
-        post_args_wrapper.set_params_with_prompts(params, proc_wrapper)
+        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()
-    printer = FsfwTmTcPrinter(tmtc_logger.logger)
+    file_logger = tmtc_logger.logger
     raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
     verificator = PusVerificator()
-    verification_wrapper = VerificationWrapper(verificator, LOGGER, printer.file_logger)
+    verification_wrapper = VerificationWrapper(verificator, _LOGGER, file_logger)
     # Create primary TM handler and add it to the CCSDS Packet Handler
-    tm_handler = PusHandler(verification_wrapper, printer, raw_logger)
+    tm_handler = PusHandler(file_logger, verification_wrapper, raw_logger)
     ccsds_handler = CcsdsTmHandler(generic_handler=None)
     ccsds_handler.add_apid_handler(tm_handler)
 
@@ -288,7 +285,7 @@ def main():
             if state.request == BackendRequest.TERMINATION_NO_ERROR:
                 sys.exit(0)
             elif state.request == BackendRequest.DELAY_IDLE:
-                LOGGER.info("TMTC Client in IDLE mode")
+                _LOGGER.info("TMTC Client in IDLE mode")
                 time.sleep(3.0)
             elif state.request == BackendRequest.DELAY_LISTENER:
                 time.sleep(0.8)

satrs-example-stm32f3-disco/pyclient/requirements.txt

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

satrs-example-stm32f3-disco/src/bin/blinky.rs

@@ -1,17 +1,15 @@
 #![no_std]
 #![no_main]
+use satrs_example_stm32f3_disco as _;
 
-extern crate panic_itm;
-
-use cortex_m_rt::entry;
-
+use stm32f3_discovery::leds::Leds;
 use stm32f3_discovery::stm32f3xx_hal::delay::Delay;
 use stm32f3_discovery::stm32f3xx_hal::{pac, prelude::*};
-use stm32f3_discovery::leds::Leds;
 use stm32f3_discovery::switch_hal::{OutputSwitch, ToggleableOutputSwitch};
 
-#[entry]
+#[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();
@@ -30,49 +28,49 @@ fn main()-> ! {
         gpioe.pe14,
         gpioe.pe15,
         &mut gpioe.moder,
-        &mut gpioe.otyper
+        &mut gpioe.otyper,
     );
     let delay_ms = 200u16;
     loop {
-        leds.ld3.toggle().ok();
+        leds.ld3_n.toggle().ok();
         delay.delay_ms(delay_ms);
-        leds.ld3.toggle().ok();
+        leds.ld3_n.toggle().ok();
         delay.delay_ms(delay_ms);
 
         //explicit on/off
-        leds.ld4.on().ok();
+        leds.ld4_nw.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld4.off().ok();
+        leds.ld4_nw.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld5.on().ok();
+        leds.ld5_ne.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld5.off().ok();
+        leds.ld5_ne.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld6.on().ok();
+        leds.ld6_w.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld6.off().ok();
+        leds.ld6_w.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld7.on().ok();
+        leds.ld7_e.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld7.off().ok();
+        leds.ld7_e.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld8.on().ok();
+        leds.ld8_sw.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld8.off().ok();
+        leds.ld8_sw.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld9.on().ok();
+        leds.ld9_se.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld9.off().ok();
+        leds.ld9_se.off().ok();
         delay.delay_ms(delay_ms);
 
-        leds.ld10.on().ok();
+        leds.ld10_s.on().ok();
         delay.delay_ms(delay_ms);
-        leds.ld10.off().ok();
+        leds.ld10_s.off().ok();
         delay.delay_ms(delay_ms);
     }
 }

satrs-example-stm32f3-disco/src/lib.rs

@@ -0,0 +1,51 @@
+#![no_main]
+#![no_std]
+
+use cortex_m_semihosting::debug;
+
+use defmt_brtt as _; // global logger
+
+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()
+}
+
+/// Terminates the application and makes a semihosting-capable debug tool exit
+/// with status code 0.
+pub fn exit() -> ! {
+    loop {
+        debug::exit(debug::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(debug::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)
+    }
+}

satrs-example-stm32f3-disco/src/main.rs

@@ -1,38 +1,40 @@
 #![no_std]
 #![no_main]
-extern crate panic_itm;
+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_example_stm32f3_disco as _;
 
 use rtic::app;
 
-use heapless::{
-    mpmc::Q16,
-    pool,
-    pool::singleton::{Box, Pool},
-};
+use heapless::{mpmc::Q8, Vec};
 #[allow(unused_imports)]
-use itm_logger::{debug, info, logger_init, warn};
-use satrs_core::spacepackets::{ecss::PusPacket, tm::PusTm};
-use satrs_core::{
-    pus::{EcssTmErrorWithSend, EcssTmSenderCore},
-    seq_count::SequenceCountProviderCore,
-};
+use rtic_monotonics::systick::fugit::{MillisDurationU32, TimerInstantU32};
+use rtic_monotonics::systick::ExtU32;
+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};
-use systick_monotonic::{fugit::Duration, Systick};
 
 const UART_BAUD: u32 = 115200;
-const BLINK_FREQ_MS: u64 = 1000;
-const TX_HANDLER_FREQ_MS: u64 = 20;
-const MIN_DELAY_BETWEEN_TX_PACKETS_MS: u16 = 5;
-const MAX_TC_LEN: usize = 200;
-const MAX_TM_LEN: usize = 200;
+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;
 
 type TxType = Tx<USART2, PA2<AF7<PushPull>>>;
 type RxType = Rx<USART2, PA3<AF7<PushPull>>>;
-type MsDuration = Duration<u64, 1, 1000>;
+type InstantFugit = TimerInstantU32<1000>;
 type TxDmaTransferType = SerialDmaTx<&'static [u8], dma1::C7, TxType>;
 type RxDmaTransferType = SerialDmaRx<&'static mut [u8], dma1::C6, RxType>;
 
@@ -51,10 +53,11 @@ static mut DMA_TX_BUF: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN];
 // transfer buffer.
 static mut DMA_RX_BUF: [u8; TC_BUF_LEN] = [0; TC_BUF_LEN];
 
-static TX_REQUESTS: Q16<(Box<poolmod::TM>, usize)> = Q16::new();
+type TmPacket = Vec<u8, MAX_TM_LEN>;
+type TcPacket = Vec<u8, MAX_TC_LEN>;
+
+static TM_REQUESTS: Q8<TmPacket> = Q8::new();
 
-const TC_POOL_SLOTS: usize = 12;
-const TM_POOL_SLOTS: usize = 12;
 use core::sync::atomic::{AtomicU16, Ordering};
 
 pub struct SeqCountProviderAtomicRef {
@@ -88,72 +91,50 @@ impl SequenceCountProviderCore<u16> for SeqCountProviderAtomicRef {
 static SEQ_COUNT_PROVIDER: SeqCountProviderAtomicRef =
     SeqCountProviderAtomicRef::new(Ordering::Relaxed);
 
-// Otherwise, warnings because of heapless pool macro.
-#[allow(non_camel_case_types)]
-mod poolmod {
-    use super::*;
-    // Must hold full TC length including COBS overhead.
-    pool!(TC: [u8; TC_BUF_LEN]);
-    // Only encoded at the end, so no need to account for COBS overhead.
-    pool!(TM: [u8; MAX_TM_LEN]);
-}
-
 pub struct TxIdle {
     tx: TxType,
     dma_channel: dma1::C7,
 }
 
-#[derive(Debug)]
-pub enum TmStoreError {
-    StoreFull,
-    StoreSlotsTooSmall,
+#[derive(Debug, defmt::Format)]
+pub enum TmSendError {
+    ByteConversion(ByteConversionError),
+    Queue,
 }
 
-impl From<TmStoreError> for EcssTmErrorWithSend<TmStoreError> {
-    fn from(value: TmStoreError) -> Self {
-        Self::SendError(value)
+impl From<ByteConversionError> for TmSendError {
+    fn from(value: ByteConversionError) -> Self {
+        Self::ByteConversion(value)
     }
 }
 
-pub struct TmSender {
-    mem_block: Option<Box<poolmod::TM>>,
-    ctx: &'static str,
+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,
         }
-
-impl TmSender {
-    pub fn new(mem_block: Box<poolmod::TM>, ctx: &'static str) -> Self {
-        Self {
-            mem_block: Some(mem_block),
-            ctx,
+        .into());
     }
-    }
-}
-
-impl EcssTmSenderCore for TmSender {
-    type Error = TmStoreError;
-
-    fn send_tm(
-        &mut self,
-        tm: PusTm,
-    ) -> Result<(), satrs_core::pus::EcssTmErrorWithSend<Self::Error>> {
-        let mem_block = self.mem_block.take();
-        if mem_block.is_none() {
-            panic!("send_tm should only be called once");
-        }
-        let mut mem_block = mem_block.unwrap();
-        if tm.len_packed() > MAX_TM_LEN {
-            return Err(EcssTmErrorWithSend::SendError(
-                TmStoreError::StoreSlotsTooSmall,
-            ));
-        }
-        tm.write_to_bytes(mem_block.as_mut_slice())
-            .map_err(|e| EcssTmErrorWithSend::EcssTmError(e.into()))?;
-        info!(target: self.ctx, "Sending TM[{},{}] with size {}", tm.service(), tm.subservice(), tm.len_packed());
-        TX_REQUESTS
-            .enqueue((mem_block, tm.len_packed()))
-            .map_err(|_| TmStoreError::StoreFull)?;
+    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 {
@@ -163,56 +144,144 @@ pub enum UartTxState {
     Transmitting(Option<TxDmaTransferType>),
 }
 
-#[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [TIM20_BRK, TIM20_UP, TIM20_TRG_COM])]
+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 core::slice::Iter;
-    use cortex_m::iprintln;
-    use satrs_core::pus::verification::FailParams;
-    use satrs_core::pus::verification::VerificationReporterCore;
-    use satrs_core::spacepackets::{
-        ecss::EcssEnumU16,
-        tc::PusTc,
-        time::cds::P_FIELD_BASE,
-        tm::{PusTm, PusTmSecondaryHeader},
-        CcsdsPacket, SpHeader,
-    };
+    use rtic_monotonics::systick::Systick;
+    use rtic_monotonics::Monotonic;
+    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 stm32f3xx_hal::Toggle;
 
     use stm32f3_discovery::switch_hal::OutputSwitch;
+    use stm32f3xx_hal::Switch;
     #[allow(dead_code)]
     type SerialType = Serial<USART2, (PA2<AF7<PushPull>>, PA3<AF7<PushPull>>)>;
 
     #[shared]
     struct Shared {
-        tx_transfer: UartTxState,
+        blink_freq: MillisDurationU32,
+        tx_shared: UartTxShared,
         rx_transfer: Option<RxDmaTransferType>,
     }
 
     #[local]
     struct Local {
+        verif_reporter: VerificationReportCreator,
         leds: Leds,
         last_dir: Direction,
-        verif_reporter: VerificationReporterCore,
         curr_dir: Iter<'static, Direction>,
     }
 
-    #[monotonic(binds = SysTick, default = true)]
-    type MonoTimer = Systick<1000>;
-
-    #[init(local = [
-        tc_pool_mem: [u8; TC_BUF_LEN * TC_POOL_SLOTS] = [0; TC_BUF_LEN * TC_POOL_SLOTS],
-        tm_pool_mem: [u8; MAX_TM_LEN * TM_POOL_SLOTS] = [0; MAX_TM_LEN * TM_POOL_SLOTS]
-    ])]
-    fn init(mut cx: init::Context) -> (Shared, Local, init::Monotonics) {
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
         let mut rcc = cx.device.RCC.constrain();
 
-        let mono = Systick::new(cx.core.SYST, 8_000_000);
-        logger_init();
+        // Initialize the systick interrupt & obtain the token to prove that we did
+        let systick_mono_token = rtic_monotonics::create_systick_token!();
+        Systick::start(cx.core.SYST, 8_000_000, systick_mono_token);
+
         let mut flash = cx.device.FLASH.constrain();
         let clocks = rcc
             .cfgr
@@ -220,17 +289,12 @@ mod app {
             .sysclk(8.MHz())
             .pclk1(8.MHz())
             .freeze(&mut flash.acr);
-        // setup ITM output
-        iprintln!(
-            &mut cx.core.ITM.stim[0],
-            "Starting sat-rs demo application for the STM32F3-Discovery"
-        );
-        let mut gpioe = cx.device.GPIOE.split(&mut rcc.ahb);
-        // Assign memory to the pools.
-        poolmod::TC::grow(cx.local.tc_pool_mem);
-        poolmod::TM::grow(cx.local.tm_pool_mem);
 
-        let verif_reporter = VerificationReporterCore::new(PUS_APID).unwrap();
+        // Set up monotonic timer.
+        //let mono_timer = MonoTimer::new(cx.core.DWT, clocks, &mut cx.core.DCB);
+
+        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,
@@ -264,125 +328,160 @@ mod app {
             clocks,
             &mut rcc.apb1,
         );
-        usart2.configure_rx_interrupt(RxEvent::Idle, Toggle::On);
+        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, Toggle::On);
+        usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Switch::On);
 
         let dma1 = cx.device.DMA1.split(&mut rcc.ahb);
-        let (tx_serial, mut rx_serial) = usart2.split();
+        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);
-        info!(target: "init", "Spawning tasks");
+        defmt::info!("Spawning tasks");
         blink::spawn().unwrap();
         serial_tx_handler::spawn().unwrap();
+
+        let verif_reporter = VerificationReportCreator::new(PUS_APID).unwrap();
+
         (
             Shared {
-                tx_transfer: UartTxState::Idle(Some(TxIdle {
+                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,
                 last_dir: Direction::North,
                 curr_dir: Direction::iter(),
-                verif_reporter,
             },
-            init::Monotonics(mono),
         )
     }
 
-    #[task(local = [leds, curr_dir, last_dir])]
-    fn blink(cx: blink::Context) {
-        let toggle_leds = |dir: &Direction| {
-            let leds = cx.local.leds;
-            let last_led = leds.for_direction(*cx.local.last_dir);
+    #[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();
-            *cx.local.last_dir = *dir;
+            *last_dir = *dir;
         };
-
-        match cx.local.curr_dir.next() {
+        loop {
+            match curr_dir.next() {
                 Some(dir) => {
                     toggle_leds(dir);
                 }
                 None => {
-                *cx.local.curr_dir = Direction::iter();
-                toggle_leds(cx.local.curr_dir.next().unwrap());
+                    *curr_dir = Direction::iter();
+                    toggle_leds(curr_dir.next().unwrap());
                 }
             }
-        blink::spawn_after(MsDuration::from_ticks(BLINK_FREQ_MS)).unwrap();
+            let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
+            Systick::delay(current_blink_freq).await;
+        }
     }
 
     #[task(
-        shared = [tx_transfer],
-        local = []
+        shared = [tx_shared],
     )]
-    fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
-        if let Some((buf, len)) = TX_REQUESTS.dequeue() {
-            cx.shared.tx_transfer.lock(|tx_state| match tx_state {
+    async fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
+        loop {
+            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 = (Systick::now() - last_completed).to_millis();
+                    if elapsed_ms < MIN_DELAY_BETWEEN_TX_PACKETS_MS {
+                        Systick::delay((MIN_DELAY_BETWEEN_TX_PACKETS_MS - elapsed_ms).millis())
+                            .await;
+                    }
+                }
+            } else {
+                // Check for completion after 1 ms
+                Systick::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.
-                    let mut_tx_dma_buf = unsafe { &mut DMA_TX_BUF };
+                            unsafe {
                                 // 0 sentinel value as start marker
-                    mut_tx_dma_buf[0] = 0;
+                                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.
-                    let encoded_len = cobs::encode(&buf[0..len], &mut mut_tx_dma_buf[1..]);
                                 // 0 end marker
-                    mut_tx_dma_buf[encoded_len + 1] = 0;
+                                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.
-                    let transfer = tx_idle
-                        .tx
-                        .write_all(&mut_tx_dma_buf[0..encoded_len + 2], tx_idle.dma_channel);
-                    *tx_state = UartTxState::Transmitting(Some(transfer));
+                            // 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(_) => {
-                    // This is a SW configuration error. Only the ISR which
-                    // detects transfer completion should be able to spawn a new
-                    // task, and that ISR should set the state to IDLE.
-                    panic!("invalid internal tx state detected")
-                }
-            })
-        } else {
-            cx.shared.tx_transfer.lock(|tx_state| {
-                if let UartTxState::Idle(_) = tx_state {
-                    serial_tx_handler::spawn_after(MsDuration::from_ticks(TX_HANDLER_FREQ_MS))
-                        .unwrap();
-                }
+                        UartTxState::Transmitting(_) => (),
                     });
+                // Check for completion after 1 ms
+                Systick::delay(1.millis()).await;
+                continue;
+            }
+            // Nothing to do, and we are idle.
+            Systick::delay(TX_HANDLER_FREQ_MS.millis()).await;
         }
     }
 
     #[task(
         local = [
-            stamp_buf: [u8; 7] = [0; 7],
+            verif_reporter,
             decode_buf: [u8; MAX_TC_LEN] = [0; MAX_TC_LEN],
             src_data_buf: [u8; MAX_TM_LEN] = [0; MAX_TM_LEN],
-            verif_reporter
+            timestamp: [u8; 7] = [0; 7],
         ],
+        shared = [blink_freq]
     )]
-    fn serial_rx_handler(
-        cx: serial_rx_handler::Context,
-        received_packet: Box<poolmod::TC>,
-        rx_len: usize,
+    async fn serial_rx_handler(
+        mut cx: serial_rx_handler::Context,
+        received_packet: Vec<u8, MAX_TC_LEN>,
     ) {
-        let tgt: &'static str = "serial_rx_handler";
-        cx.local.stamp_buf[0] = P_FIELD_BASE;
-        info!(target: tgt, "Received packet with {} bytes", rx_len);
+        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;
@@ -393,168 +492,149 @@ mod app {
             }
         }
         if start_idx.is_none() {
-            warn!(
-                target: tgt,
-                "decoding error, can only process cobs encoded frames, data is all 0"
-            );
+            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) => {
-                info!(target: tgt, "Decoded packet length: {}", len);
-                let pus_tc = PusTc::from_bytes(decode_buf);
-                let verif_reporter = cx.local.verif_reporter;
+                defmt::info!("Decoded packet length: {}", len);
+                let pus_tc = PusTcReader::new(decode_buf);
                 match pus_tc {
-                    Ok((tc, tc_len)) => handle_tc(
-                        tc,
-                        tc_len,
-                        verif_reporter,
+                    Ok((tc, _tc_len)) => {
+                        match convert_pus_tc_to_request(
+                            &tc,
+                            cx.local.verif_reporter,
                             cx.local.src_data_buf,
-                        cx.local.stamp_buf,
-                        tgt,
-                    ),
+                            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);
+                                    }
+                                    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) => {
-                        warn!(target: tgt, "Error unpacking PUS TC: {}", e);
+                                // TODO: Error handling: Send verification failure based on request error.
+                                defmt::warn!("request error {}", e);
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        defmt::warn!("Error unpacking PUS TC: {}", e);
                     }
                 }
             }
             Err(_) => {
-                warn!(
-                    target: tgt,
-                    "decoding error, can only process cobs encoded frames"
-                )
+                defmt::warn!("decoding error, can only process cobs encoded frames")
             }
         }
     }
 
-    fn handle_tc(
-        tc: PusTc,
-        tc_len: usize,
-        verif_reporter: &mut VerificationReporterCore,
-        src_data_buf: &mut [u8; MAX_TM_LEN],
-        stamp_buf: &[u8; 7],
-        tgt: &'static str,
-    ) {
-        info!(
-            target: tgt,
-            "Found PUS TC [{},{}] with length {}",
-            tc.service(),
-            tc.subservice(),
-            tc_len
-        );
+    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;
+        }
+    }
 
-        let token = verif_reporter.add_tc(&tc);
-        if tc.apid() != PUS_APID {
-            warn!(target: tgt, "Received tc with unknown APID {}", tc.apid());
-            let sendable = verif_reporter
-                .acceptance_failure(
+    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,
-                    token,
-                    &SEQ_COUNT_PROVIDER,
-                    FailParams::new(stamp_buf, &EcssEnumU16::new(0), None),
+                accepted_token,
+                SEQ_COUNT_PROVIDER.get(),
+                0,
+                &timestamp,
             )
             .unwrap();
-            let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-            let mut sender = TmSender::new(mem_block, tgt);
-            if let Err(e) =
-                verif_reporter.send_acceptance_failure(sendable, &SEQ_COUNT_PROVIDER, &mut sender)
-            {
-                warn!(target: tgt, "Sending acceptance failure failed: {:?}", e.0);
-            };
-            return;
+        let result = send_tm(tm_creator);
+        if let Err(e) = result {
+            handle_tm_send_error(e);
+        }
+        started_token
     }
-        let sendable = verif_reporter
-            .acceptance_success(src_data_buf, token, &SEQ_COUNT_PROVIDER, stamp_buf)
-            .unwrap();
 
-        let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-        let mut sender = TmSender::new(mem_block, tgt);
-        let accepted_token = match verif_reporter.send_acceptance_success(
-            sendable,
-            &SEQ_COUNT_PROVIDER,
-            &mut sender,
+    fn handle_completion_verification(
+        started_token: VerificationToken<TcStateStarted>,
+        verif_reporter: &mut VerificationReportCreator,
+        src_data_buf: &mut [u8],
+        timestamp: &[u8],
     ) {
-            Ok(token) => token,
-            Err(e) => {
-                warn!(target: "serial_rx_handler", "Sending acceptance success failed: {:?}", e.0);
-                return;
-            }
-        };
-
-        if tc.service() == 17 {
-            if tc.subservice() == 1 {
-                let sendable = verif_reporter
-                    .start_success(src_data_buf, accepted_token, &SEQ_COUNT_PROVIDER, stamp_buf)
-                    .unwrap();
-                let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-                let mut sender = TmSender::new(mem_block, tgt);
-                let started_token = match verif_reporter.send_start_success(
-                    sendable,
-                    &SEQ_COUNT_PROVIDER,
-                    &mut sender,
-                ) {
-                    Ok(token) => token,
-                    Err(e) => {
-                        warn!(target: tgt, "Sending acceptance success failed: {:?}", e.0);
-                        return;
-                    }
-                };
-                info!(
-                    target: tgt,
-                    "Received PUS ping telecommand, sending ping reply TM[17,2]"
+        let result = send_tm(
+            verif_reporter
+                .completion_success(
+                    src_data_buf,
+                    started_token,
+                    SEQ_COUNT_PROVIDER.get(),
+                    0,
+                    timestamp,
+                )
+                .unwrap(),
         );
-                let mut sp_header =
-                    SpHeader::tc_unseg(PUS_APID, SEQ_COUNT_PROVIDER.get(), 0).unwrap();
-                let sec_header = PusTmSecondaryHeader::new_simple(17, 2, stamp_buf);
-                let ping_reply = PusTm::new(&mut sp_header, sec_header, None, true);
-                let mut mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-                let reply_len = ping_reply.write_to_bytes(mem_block.as_mut_slice()).unwrap();
-                if TX_REQUESTS.enqueue((mem_block, reply_len)).is_err() {
-                    warn!(target: tgt, "TC queue full");
-                    return;
-                }
-                SEQ_COUNT_PROVIDER.increment();
-                let sendable = verif_reporter
-                    .completion_success(src_data_buf, started_token, &SEQ_COUNT_PROVIDER, stamp_buf)
-                    .unwrap();
-                let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-                let mut sender = TmSender::new(mem_block, tgt);
-                if let Err(e) = verif_reporter.send_step_or_completion_success(
-                    sendable,
-                    &SEQ_COUNT_PROVIDER,
-                    &mut sender,
-                ) {
-                    warn!(target: tgt, "Sending completion success failed: {:?}", e.0);
-                }
-            } else {
-                // TODO: Invalid subservice
-            }
+        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 memory pool here
+                // during the interrupt. There are multiple ways to do this, we use a stack allocaed vector here
                 // to do this.
-                let mut mem_block = poolmod::TC::alloc()
-                    .expect("allocating memory block for rx failed")
-                    .init([0u8; TC_BUF_LEN]);
-                // Copy data into memory pool.
-                mem_block.copy_from_slice(buf);
+                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));
-                // Only send owning pointer to pool memory and the received packet length.
-                serial_rx_handler::spawn(mem_block, TC_BUF_LEN)
-                    .expect("spawning rx handler task failed");
+
+                // 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.
-                warn!(
+                defmt::warn!(
                     "rx transfer with maximum length {}, might miss data",
                     TC_BUF_LEN
                 );
@@ -562,23 +642,26 @@ mod app {
         });
     }
 
-    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_transfer])]
+    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_shared])]
     fn serial_isr(mut cx: serial_isr::Context) {
-        cx.shared.tx_transfer.lock(|tx_state| match tx_state {
+        cx.shared
+            .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, tx) = transfer.stop();
-                    *tx_state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
-                    serial_tx_handler::spawn_after(MsDuration::from_ticks(
-                        MIN_DELAY_BETWEEN_TX_PACKETS_MS.into(),
-                    ))
-                    .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(Systick::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.
@@ -586,17 +669,14 @@ mod app {
                 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 memory pool here
-                // to do this.
-                let mut mem_block = poolmod::TC::alloc()
-                    .expect("allocating memory block for rx failed")
-                    .init([0u8; TC_BUF_LEN]);
-                // Copy data into memory pool.
-                mem_block[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
+                // 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);
-                // Only send owning pointer to pool memory and the received packet length.
-                serial_rx_handler::spawn(mem_block, rx_len as usize)
-                    .expect("spawning rx handler task failed");
+                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler failed");
                 *rx_transfer = Some(rx.read_exact(buf, ch));
             }
         });

satrs-example-stm32f3-disco/vscode/extensions.json

@@ -5,7 +5,7 @@
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
 		"rust-lang.rust",
-		"marus25.cortex-debug",
+		"probe-rs.probe-rs-debugger"
 	],
 	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
 	"unwantedRecommendations": []

satrs-example-stm32f3-disco/vscode/launch.json

@@ -0,0 +1,22 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "preLaunchTask": "${defaultBuildTask}",
+      "type": "probe-rs-debug",
+      "request": "launch",
+      "name": "probe-rs Debugging ",
+      "flashingConfig": {
+        "flashingEnabled": true
+      },
+      "chip": "STM32F303VCTx",
+      "coreConfigs": [
+        {
+          "programBinary": "${workspaceFolder}/target/thumbv7em-none-eabihf/debug/satrs-example-stm32f3-disco",
+          "rttEnabled": true,
+          "svdFile": "STM32F303.svd"
+        }
+      ]
+    }
+  ]
+}

satrs-example-stm32f3-disco/vscode/openocd-helpers.tcl

@@ -11,7 +11,8 @@ proc CDSWOConfigure { CDCPUFreqHz CDSWOFreqHz CDSWOOutput } {
     # Alternative option: Pipe ITM output into itm.txt file
     # tpiu config internal itm.txt uart off $CDCPUFreqHz
 
-    # Default option so SWO display of VS code works.
+    # Default option so SWO display of VS code works. Please note that this might not be required
+    # anymore starting at openocd v0.12.0
     tpiu config internal $CDSWOOutput uart off $CDCPUFreqHz $CDSWOFreqHz
     itm port 0 on
 }

satrs-example/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-example"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 default-run = "satrs-example"
@@ -17,16 +17,23 @@ zerocopy = "0.6"
 csv = "1"
 num_enum = "0.7"
 thiserror = "1"
+lazy_static = "1"
+strum = { version = "0.26", features = ["derive"] }
 derive-new = "0.5"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 
 [dependencies.satrs]
-# version = "0.1.1"
 path = "../satrs"
+features = ["test_util"]
 
 [dependencies.satrs-mib]
-# version = "0.1.0"
+version = "0.1.1"
 path = "../satrs-mib"
 
 [features]
 dyn_tmtc = []
 default = ["dyn_tmtc"]
+
+[dev-dependencies]
+env_logger = "0.11"

satrs-example/satrs-tmtc/common.py

@@ -4,11 +4,12 @@ import dataclasses
 import enum
 import struct
 
-from spacepackets.ecss.tc import PacketId, PacketType
 
-EXAMPLE_PUS_APID = 0x02
-EXAMPLE_PUS_PACKET_ID_TM = PacketId(PacketType.TM, True, EXAMPLE_PUS_APID)
-TM_PACKET_IDS = [EXAMPLE_PUS_PACKET_ID_TM]
+class Apid(enum.IntEnum):
+    SCHED = 1
+    GENERIC_PUS = 2
+    ACS = 3
+    CFDP = 4
 
 
 class EventSeverity(enum.IntEnum):
@@ -36,8 +37,8 @@ class EventU32:
         )
 
 
-class RequestTargetId(enum.IntEnum):
-    ACS = 1
+class AcsId(enum.IntEnum):
+    MGM_0 = 0
 
 
 class AcsHkIds(enum.IntEnum):

satrs-example/satrs-tmtc/main.py

@@ -3,10 +3,11 @@
 import logging
 import sys
 import time
-from typing import Optional
+from typing import Any, Optional
 from prompt_toolkit.history import History
 from prompt_toolkit.history import FileHistory
 
+from spacepackets.ccsds import PacketId, PacketType
 import tmtccmd
 from spacepackets.ecss import PusTelemetry, PusVerificator
 from spacepackets.ecss.pus_17_test import Service17Tm
@@ -16,7 +17,7 @@ from spacepackets.ccsds.time import CdsShortTimestamp
 from tmtccmd import TcHandlerBase, ProcedureParamsWrapper
 from tmtccmd.core.base import BackendRequest
 from tmtccmd.pus import VerificationWrapper
-from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
+from tmtccmd.tmtc import CcsdsTmHandler, GenericApidHandlerBase
 from tmtccmd.com import ComInterface
 from tmtccmd.config import (
     CmdTreeNode,
@@ -46,7 +47,7 @@ from tmtccmd.util.obj_id import ObjectIdDictT
 
 
 import pus_tc
-from common import EXAMPLE_PUS_APID, TM_PACKET_IDS, EventU32
+from common import Apid, EventU32
 
 _LOGGER = logging.getLogger()
 
@@ -62,10 +63,13 @@ class SatRsConfigHook(HookBase):
         )
 
         assert self.cfg_path is not None
+        packet_id_list = []
+        for apid in Apid:
+            packet_id_list.append(PacketId(PacketType.TM, True, apid))
         cfg = create_com_interface_cfg_default(
             com_if_key=com_if_key,
             json_cfg_path=self.cfg_path,
-            space_packet_ids=TM_PACKET_IDS,
+            space_packet_ids=packet_id_list,
         )
         assert cfg is not None
         return create_com_interface_default(cfg)
@@ -85,19 +89,19 @@ class SatRsConfigHook(HookBase):
         return get_core_object_ids()
 
 
-class PusHandler(SpecificApidHandlerBase):
+class PusHandler(GenericApidHandlerBase):
     def __init__(
         self,
         file_logger: logging.Logger,
         verif_wrapper: VerificationWrapper,
         raw_logger: RawTmtcTimedLogWrapper,
     ):
-        super().__init__(EXAMPLE_PUS_APID, None)
+        super().__init__(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):
+    def handle_tm(self, apid: int, packet: bytes, _user_args: Any):
         try:
             pus_tm = PusTelemetry.unpack(packet, time_reader=CdsShortTimestamp.empty())
         except ValueError as e:
@@ -177,7 +181,7 @@ class TcHandler(TcHandlerBase):
             tc_sched_timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE,
             seq_cnt_provider=seq_count_provider,
             pus_verificator=self.verif_wrapper.pus_verificator,
-            default_pus_apid=EXAMPLE_PUS_APID,
+            default_pus_apid=None,
         )
 
     def send_cb(self, send_params: SendCbParams):
@@ -221,7 +225,6 @@ def main():
         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
     )
@@ -233,8 +236,9 @@ def main():
     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)
+    ccsds_handler = CcsdsTmHandler(generic_handler=tm_handler)
+    # TODO: We could add the CFDP handler for the CFDP APID at a later stage.
+    # ccsds_handler.add_apid_handler(tm_handler)
 
     # Create TC handler
     seq_count_provider = PusFileSeqCountProvider()

satrs-example/satrs-tmtc/pus_tc.py

@@ -1,27 +1,58 @@
 import datetime
+import struct
 import logging
 
 from spacepackets.ccsds import CdsShortTimestamp
 from spacepackets.ecss import PusTelecommand
 from tmtccmd.config import CmdTreeNode
+from tmtccmd.pus.tc.s200_fsfw_mode import Mode
 from tmtccmd.tmtc import DefaultPusQueueHelper
 from tmtccmd.pus.s11_tc_sched import create_time_tagged_cmd
-from tmtccmd.pus.tc.s3_fsfw_hk import create_request_one_hk_command
+from tmtccmd.pus.s200_fsfw_mode import Subservice as ModeSubservice
 
-from common import (
-    EXAMPLE_PUS_APID,
-    make_addressable_id,
-    RequestTargetId,
-    AcsHkIds,
-)
+from common import AcsId, Apid
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def create_set_mode_cmd(
+    apid: int, unique_id: int, mode: int, submode: int
+) -> PusTelecommand:
+    app_data = bytearray()
+    app_data.extend(struct.pack("!I", unique_id))
+    app_data.extend(struct.pack("!I", mode))
+    app_data.extend(struct.pack("!H", submode))
+    return PusTelecommand(
+        service=200,
+        subservice=ModeSubservice.TC_MODE_COMMAND,
+        apid=apid,
+        app_data=app_data,
+    )
+
+
 def create_cmd_definition_tree() -> CmdTreeNode:
 
     root_node = CmdTreeNode.root_node()
 
+    hk_node = CmdTreeNode("hk", "Housekeeping Node", hide_children_for_print=True)
+    hk_node.add_child(CmdTreeNode("one_shot_hk", "Request One Shot HK set"))
+    hk_node.add_child(
+        CmdTreeNode("enable", "Enable periodic housekeeping data generation")
+    )
+    hk_node.add_child(
+        CmdTreeNode("disable", "Disable periodic housekeeping data generation")
+    )
+
+    mode_node = CmdTreeNode("mode", "Mode Node", hide_children_for_print=True)
+    set_mode_node = CmdTreeNode(
+        "set_mode", "Set Node", hide_children_which_are_leaves=True
+    )
+    set_mode_node.add_child(CmdTreeNode("off", "Set OFF Mode"))
+    set_mode_node.add_child(CmdTreeNode("on", "Set ON Mode"))
+    set_mode_node.add_child(CmdTreeNode("normal", "Set NORMAL Mode"))
+    mode_node.add_child(set_mode_node)
+    mode_node.add_child(CmdTreeNode("read_mode", "Read Mode"))
+
     test_node = CmdTreeNode("test", "Test Node")
     test_node.add_child(CmdTreeNode("ping", "Send PUS ping TC"))
     test_node.add_child(CmdTreeNode("trigger_event", "Send PUS test to trigger event"))
@@ -37,7 +68,9 @@ def create_cmd_definition_tree() -> CmdTreeNode:
 
     acs_node = CmdTreeNode("acs", "ACS Subsystem Node")
     mgm_node = CmdTreeNode("mgms", "MGM devices node")
-    mgm_node.add_child(CmdTreeNode("one_shot_hk", "Request one shot HK"))
+    mgm_node.add_child(mode_node)
+    mgm_node.add_child(hk_node)
+
     acs_node.add_child(mgm_node)
     root_node.add_child(acs_node)
 
@@ -54,10 +87,14 @@ def pack_pus_telecommands(q: DefaultPusQueueHelper, cmd_path: str):
         assert len(cmd_path_list) >= 2
         if cmd_path_list[1] == "ping":
             q.add_log_cmd("Sending PUS ping telecommand")
-            return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
+            return q.add_pus_tc(
+                PusTelecommand(apid=Apid.GENERIC_PUS, service=17, subservice=1)
+            )
         elif cmd_path_list[1] == "trigger_event":
             q.add_log_cmd("Triggering test event")
-            return q.add_pus_tc(PusTelecommand(service=17, subservice=128))
+            return q.add_pus_tc(
+                PusTelecommand(apid=Apid.GENERIC_PUS, service=17, subservice=128)
+            )
     if cmd_path_list[0] == "scheduler":
         assert len(cmd_path_list) >= 2
         if cmd_path_list[1] == "schedule_ping_10_secs_ahead":
@@ -69,17 +106,38 @@ def pack_pus_telecommands(q: DefaultPusQueueHelper, cmd_path: str):
                 create_time_tagged_cmd(
                     time_stamp,
                     PusTelecommand(service=17, subservice=1),
-                    apid=EXAMPLE_PUS_APID,
+                    apid=Apid.SCHED,
                 )
             )
     if cmd_path_list[0] == "acs":
         assert len(cmd_path_list) >= 2
-        if cmd_path_list[1] == "mgm":
+        if cmd_path_list[1] == "mgms":
             assert len(cmd_path_list) >= 3
-            if cmd_path_list[2] == "one_shot_hk":
+            if cmd_path_list[2] == "hk":
+                if cmd_path_list[3] == "one_shot_hk":
                     q.add_log_cmd("Sending HK one shot request")
-                q.add_pus_tc(
-                    create_request_one_hk_command(
-                        make_addressable_id(RequestTargetId.ACS, AcsHkIds.MGM_SET)
-                    )
+                    # TODO: Fix
+                    # q.add_pus_tc(
+                    #   create_request_one_hk_command(
+                    #    make_addressable_id(Apid.ACS, AcsId.MGM_SET)
+                    # )
+                    # )
+            if cmd_path_list[2] == "mode":
+                if cmd_path_list[3] == "set_mode":
+                    handle_set_mode_cmd(
+                        q, "MGM 0", cmd_path_list[4], Apid.ACS, AcsId.MGM_0
                     )
+
+
+def handle_set_mode_cmd(
+    q: DefaultPusQueueHelper, target_str: str, mode_str: str, apid: int, unique_id: int
+):
+    if mode_str == "off":
+        q.add_log_cmd(f"Sending Mode OFF to {target_str}")
+        q.add_pus_tc(create_set_mode_cmd(apid, unique_id, Mode.OFF, 0))
+    elif mode_str == "on":
+        q.add_log_cmd(f"Sending Mode ON to {target_str}")
+        q.add_pus_tc(create_set_mode_cmd(apid, unique_id, Mode.ON, 0))
+    elif mode_str == "normal":
+        q.add_log_cmd(f"Sending Mode NORMAL to {target_str}")
+        q.add_pus_tc(create_set_mode_cmd(apid, unique_id, Mode.NORMAL, 0))

satrs-example/src/acs.rs

@@ -1,118 +0,0 @@
-use std::sync::mpsc::{self, TryRecvError};
-
-use log::{info, warn};
-use satrs::pus::verification::{VerificationReporterWithSender, VerificationReportingProvider};
-use satrs::pus::{EcssTmSender, PusTmWrapper};
-use satrs::request::TargetAndApidId;
-use satrs::spacepackets::ecss::hk::Subservice as HkSubservice;
-use satrs::{
-    hk::HkRequest,
-    spacepackets::{
-        ecss::tm::{PusTmCreator, PusTmSecondaryHeader},
-        time::cds::{DaysLen16Bits, TimeProvider},
-        SequenceFlags, SpHeader,
-    },
-};
-use satrs_example::config::{RequestTargetId, PUS_APID};
-
-use crate::{
-    hk::{AcsHkIds, HkUniqueId},
-    requests::{Request, RequestWithToken},
-    update_time,
-};
-
-pub struct AcsTask {
-    timestamp: [u8; 7],
-    time_provider: TimeProvider<DaysLen16Bits>,
-    verif_reporter: VerificationReporterWithSender,
-    tm_sender: Box<dyn EcssTmSender>,
-    request_rx: mpsc::Receiver<RequestWithToken>,
-}
-
-impl AcsTask {
-    pub fn new(
-        tm_sender: impl EcssTmSender,
-        request_rx: mpsc::Receiver<RequestWithToken>,
-        verif_reporter: VerificationReporterWithSender,
-    ) -> Self {
-        Self {
-            timestamp: [0; 7],
-            time_provider: TimeProvider::new_with_u16_days(0, 0),
-            verif_reporter,
-            tm_sender: Box::new(tm_sender),
-            request_rx,
-        }
-    }
-
-    fn handle_hk_request(&mut self, target_id: u32, unique_id: u32) {
-        assert_eq!(target_id, RequestTargetId::AcsSubsystem as u32);
-        if unique_id == AcsHkIds::TestMgmSet as u32 {
-            let mut sp_header = SpHeader::tm(PUS_APID, SequenceFlags::Unsegmented, 0, 0).unwrap();
-            let sec_header = PusTmSecondaryHeader::new_simple(
-                3,
-                HkSubservice::TmHkPacket as u8,
-                &self.timestamp,
-            );
-            let mut buf: [u8; 8] = [0; 8];
-            let hk_id = HkUniqueId::new(target_id, unique_id);
-            hk_id.write_to_be_bytes(&mut buf).unwrap();
-            let pus_tm = PusTmCreator::new(&mut sp_header, sec_header, &buf, true);
-            self.tm_sender
-                .send_tm(PusTmWrapper::Direct(pus_tm))
-                .expect("Sending HK TM failed");
-        }
-        // TODO: Verification failure for invalid unique IDs.
-    }
-
-    pub fn try_reading_one_request(&mut self) -> bool {
-        match self.request_rx.try_recv() {
-            Ok(request) => {
-                info!(
-                    "ACS thread: Received HK request {:?}",
-                    request.targeted_request
-                );
-                let target_and_apid_id = TargetAndApidId::from(request.targeted_request.target_id);
-                match request.targeted_request.request {
-                    Request::Hk(hk_req) => match hk_req {
-                        HkRequest::OneShot(unique_id) => {
-                            self.handle_hk_request(target_and_apid_id.target(), unique_id)
-                        }
-                        HkRequest::Enable(_) => {}
-                        HkRequest::Disable(_) => {}
-                        HkRequest::ModifyCollectionInterval(_, _) => {}
-                    },
-                    Request::Mode(_mode_req) => {
-                        warn!("mode request handling not implemented yet")
-                    }
-                    Request::Action(_action_req) => {
-                        warn!("action request handling not implemented yet")
-                    }
-                }
-                let started_token = self
-                    .verif_reporter
-                    .start_success(request.token, &self.timestamp)
-                    .expect("Sending start success failed");
-                self.verif_reporter
-                    .completion_success(started_token, &self.timestamp)
-                    .expect("Sending completion success failed");
-                true
-            }
-            Err(e) => match e {
-                TryRecvError::Empty => false,
-                TryRecvError::Disconnected => {
-                    warn!("ACS thread: Message Queue TX disconnected!");
-                    false
-                }
-            },
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        update_time(&mut self.time_provider, &mut self.timestamp);
-        loop {
-            if !self.try_reading_one_request() {
-                break;
-            }
-        }
-    }
-}

satrs-example/src/acs/mgm.rs

@@ -0,0 +1,282 @@
+use derive_new::new;
+use satrs::hk::{HkRequest, HkRequestVariant};
+use satrs::queue::{GenericSendError, GenericTargetedMessagingError};
+use satrs::spacepackets::ecss::hk;
+use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use satrs::spacepackets::SpHeader;
+use satrs_example::{DeviceMode, TimeStampHelper};
+use std::sync::mpsc::{self};
+use std::sync::{Arc, Mutex};
+
+use satrs::mode::{
+    ModeAndSubmode, ModeError, ModeProvider, ModeReply, ModeRequest, ModeRequestHandler,
+};
+use satrs::pus::{EcssTmSender, PusTmVariant};
+use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
+use satrs_example::config::components::PUS_MODE_SERVICE;
+
+use crate::pus::hk::{HkReply, HkReplyVariant};
+use crate::requests::CompositeRequest;
+
+use serde::{Deserialize, Serialize};
+
+const GAUSS_TO_MICROTESLA_FACTOR: f32 = 100.0;
+// This is the selected resoltion for the STM LIS3MDL device for the 4 Gauss sensitivity setting.
+const FIELD_LSB_PER_GAUSS_4_SENS: f32 = 1.0 / 6842.0;
+
+pub trait SpiInterface {
+    type Error;
+    fn transfer(&mut self, tx: &[u8], rx: &mut [u8]) -> Result<(), Self::Error>;
+}
+
+#[derive(Default)]
+pub struct SpiDummyInterface {
+    pub dummy_val_0: i16,
+    pub dummy_val_1: i16,
+    pub dummy_val_2: i16,
+}
+
+impl SpiInterface for SpiDummyInterface {
+    type Error = ();
+
+    fn transfer(&mut self, _tx: &[u8], rx: &mut [u8]) -> Result<(), Self::Error> {
+        rx[0..2].copy_from_slice(&self.dummy_val_0.to_be_bytes());
+        rx[2..4].copy_from_slice(&self.dummy_val_1.to_be_bytes());
+        rx[4..6].copy_from_slice(&self.dummy_val_2.to_be_bytes());
+        Ok(())
+    }
+}
+
+#[derive(Default, Debug, Copy, Clone, Serialize, Deserialize)]
+pub struct MgmData {
+    pub valid: bool,
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+pub struct MpscModeLeafInterface {
+    pub request_rx: mpsc::Receiver<GenericMessage<ModeRequest>>,
+    pub reply_tx_to_pus: mpsc::Sender<GenericMessage<ModeReply>>,
+    pub reply_tx_to_parent: mpsc::Sender<GenericMessage<ModeReply>>,
+}
+
+/// Example MGM device handler strongly based on the LIS3MDL MEMS device.
+#[derive(new)]
+#[allow(clippy::too_many_arguments)]
+pub struct MgmHandlerLis3Mdl<ComInterface: SpiInterface, TmSender: EcssTmSender> {
+    id: UniqueApidTargetId,
+    dev_str: &'static str,
+    mode_interface: MpscModeLeafInterface,
+    composite_request_receiver: mpsc::Receiver<GenericMessage<CompositeRequest>>,
+    hk_reply_sender: mpsc::Sender<GenericMessage<HkReply>>,
+    tm_sender: TmSender,
+    com_interface: ComInterface,
+    shared_mgm_set: Arc<Mutex<MgmData>>,
+    #[new(value = "ModeAndSubmode::new(satrs_example::DeviceMode::Off as u32, 0)")]
+    mode_and_submode: ModeAndSubmode,
+    #[new(default)]
+    tx_buf: [u8; 12],
+    #[new(default)]
+    rx_buf: [u8; 12],
+    #[new(default)]
+    tm_buf: [u8; 16],
+    #[new(default)]
+    stamp_helper: TimeStampHelper,
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSender> MgmHandlerLis3Mdl<ComInterface, TmSender> {
+    pub fn periodic_operation(&mut self) {
+        self.stamp_helper.update_from_now();
+        // Handle requests.
+        self.handle_composite_requests();
+        self.handle_mode_requests();
+        if self.mode() == DeviceMode::Normal as u32 {
+            log::trace!("polling LIS3MDL sensor {}", self.dev_str);
+            // Communicate with the device.
+            let result = self.com_interface.transfer(&self.tx_buf, &mut self.rx_buf);
+            assert!(result.is_ok());
+            // Actual data begins on the second byte, similarly to how a lot of SPI devices behave.
+            let x_raw = i16::from_be_bytes(self.rx_buf[1..3].try_into().unwrap());
+            let y_raw = i16::from_be_bytes(self.rx_buf[3..5].try_into().unwrap());
+            let z_raw = i16::from_be_bytes(self.rx_buf[5..7].try_into().unwrap());
+            // Simple scaling to retrieve the float value, assuming a sensor resolution of
+            let mut mgm_guard = self.shared_mgm_set.lock().unwrap();
+            mgm_guard.x = x_raw as f32 * GAUSS_TO_MICROTESLA_FACTOR * FIELD_LSB_PER_GAUSS_4_SENS;
+            mgm_guard.y = y_raw as f32 * GAUSS_TO_MICROTESLA_FACTOR * FIELD_LSB_PER_GAUSS_4_SENS;
+            mgm_guard.z = z_raw as f32 * GAUSS_TO_MICROTESLA_FACTOR * FIELD_LSB_PER_GAUSS_4_SENS;
+            drop(mgm_guard);
+        }
+    }
+
+    pub fn handle_composite_requests(&mut self) {
+        loop {
+            match self.composite_request_receiver.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) => {}
+                },
+
+                Err(e) => {
+                    if e != mpsc::TryRecvError::Empty {
+                        log::warn!(
+                            "{}: failed to receive composite request: {:?}",
+                            self.dev_str,
+                            e
+                        );
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn handle_hk_request(&mut self, requestor_info: &MessageMetadata, hk_request: &HkRequest) {
+        match hk_request.variant {
+            HkRequestVariant::OneShot => {
+                self.hk_reply_sender
+                    .send(GenericMessage::new(
+                        *requestor_info,
+                        HkReply::new(hk_request.unique_id, HkReplyVariant::Ack),
+                    ))
+                    .expect("failed to send HK reply");
+                let sec_header = PusTmSecondaryHeader::new(
+                    3,
+                    hk::Subservice::TmHkPacket as u8,
+                    0,
+                    0,
+                    self.stamp_helper.stamp(),
+                );
+                let mgm_snapshot = *self.shared_mgm_set.lock().unwrap();
+                // Use binary serialization here. We want the data to be tightly packed.
+                self.tm_buf[0] = mgm_snapshot.valid as u8;
+                self.tm_buf[1..5].copy_from_slice(&mgm_snapshot.x.to_be_bytes());
+                self.tm_buf[5..9].copy_from_slice(&mgm_snapshot.y.to_be_bytes());
+                self.tm_buf[9..13].copy_from_slice(&mgm_snapshot.z.to_be_bytes());
+                let hk_tm = PusTmCreator::new(
+                    SpHeader::new_from_apid(self.id.apid),
+                    sec_header,
+                    &self.tm_buf[0..12],
+                    true,
+                );
+                self.tm_sender
+                    .send_tm(self.id.id(), PusTmVariant::Direct(hk_tm))
+                    .expect("failed to send HK TM");
+            }
+            HkRequestVariant::EnablePeriodic => todo!(),
+            HkRequestVariant::DisablePeriodic => todo!(),
+            HkRequestVariant::ModifyCollectionInterval(_) => todo!(),
+        }
+    }
+
+    pub fn handle_mode_requests(&mut self) {
+        loop {
+            // TODO: Only allow one set mode request per cycle?
+            match self.mode_interface.request_rx.try_recv() {
+                Ok(msg) => {
+                    let result = self.handle_mode_request(msg);
+                    // TODO: Trigger event?
+                    if result.is_err() {
+                        log::warn!(
+                            "{}: mode request failed with error {:?}",
+                            self.dev_str,
+                            result.err().unwrap()
+                        );
+                    }
+                }
+                Err(e) => {
+                    if e != mpsc::TryRecvError::Empty {
+                        log::warn!("{}: failed to receive mode request: {:?}", self.dev_str, e);
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSender> ModeProvider
+    for MgmHandlerLis3Mdl<ComInterface, TmSender>
+{
+    fn mode_and_submode(&self) -> ModeAndSubmode {
+        self.mode_and_submode
+    }
+}
+
+impl<ComInterface: SpiInterface, TmSender: EcssTmSender> ModeRequestHandler
+    for MgmHandlerLis3Mdl<ComInterface, TmSender>
+{
+    type Error = ModeError;
+    fn start_transition(
+        &mut self,
+        requestor: MessageMetadata,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), satrs::mode::ModeError> {
+        log::info!(
+            "{}: transitioning to mode {:?}",
+            self.dev_str,
+            mode_and_submode
+        );
+        self.mode_and_submode = mode_and_submode;
+        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() != PUS_MODE_SERVICE.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_SERVICE.id() {
+            log::warn!(
+                "can not send back mode reply to sender {}",
+                requestor.sender_id()
+            );
+        }
+        self.mode_interface
+            .reply_tx_to_pus
+            .send(GenericMessage::new(requestor, reply))
+            .map_err(|_| GenericTargetedMessagingError::Send(GenericSendError::RxDisconnected))?;
+        Ok(())
+    }
+
+    fn handle_mode_info(
+        &mut self,
+        _requestor_info: MessageMetadata,
+        _info: ModeAndSubmode,
+    ) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}

satrs-example/src/acs/mod.rs

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

satrs-example/src/bin/simpleclient.rs

@@ -12,8 +12,7 @@ use std::time::Duration;
 fn main() {
     let mut buf = [0; 32];
     let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
-    let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+    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}");

satrs-example/src/ccsds.rs

@@ -1,44 +0,0 @@
-use satrs::pus::ReceivesEcssPusTc;
-use satrs::spacepackets::{CcsdsPacket, SpHeader};
-use satrs::tmtc::{CcsdsPacketHandler, ReceivesCcsdsTc};
-use satrs_example::config::PUS_APID;
-
-#[derive(Clone)]
-pub struct CcsdsReceiver<
-    TcSource: ReceivesCcsdsTc<Error = E> + ReceivesEcssPusTc<Error = E> + Clone,
-    E,
-> {
-    pub tc_source: TcSource,
-}
-
-impl<
-        TcSource: ReceivesCcsdsTc<Error = E> + ReceivesEcssPusTc<Error = E> + Clone + 'static,
-        E: 'static,
-    > CcsdsPacketHandler for CcsdsReceiver<TcSource, E>
-{
-    type Error = E;
-
-    fn valid_apids(&self) -> &'static [u16] {
-        &[PUS_APID]
-    }
-
-    fn handle_known_apid(
-        &mut self,
-        sp_header: &SpHeader,
-        tc_raw: &[u8],
-    ) -> Result<(), Self::Error> {
-        if sp_header.apid() == PUS_APID {
-            return self.tc_source.pass_ccsds(sp_header, tc_raw);
-        }
-        Ok(())
-    }
-
-    fn handle_unknown_apid(
-        &mut self,
-        sp_header: &SpHeader,
-        _tc_raw: &[u8],
-    ) -> Result<(), Self::Error> {
-        println!("Unknown APID 0x{:x?} detected", sp_header.apid());
-        Ok(())
-    }
-}

satrs-example/src/config.rs

@@ -1,7 +1,12 @@
-use satrs::res_code::ResultU16;
+use lazy_static::lazy_static;
+use satrs::{
+    res_code::ResultU16,
+    spacepackets::{PacketId, PacketType},
+};
 use satrs_mib::res_code::ResultU16Info;
 use satrs_mib::resultcode;
-use std::net::Ipv4Addr;
+use std::{collections::HashSet, net::Ipv4Addr};
+use strum::IntoEnumIterator;
 
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 use satrs::{
@@ -9,8 +14,6 @@ use satrs::{
     pool::{StaticMemoryPool, StaticPoolConfig},
 };
 
-pub const PUS_APID: u16 = 0x02;
-
 #[derive(Copy, Clone, PartialEq, Eq, Debug, TryFromPrimitive, IntoPrimitive)]
 #[repr(u8)]
 pub enum CustomPusServiceId {
@@ -29,6 +32,7 @@ pub const AOCS_APID: u16 = 1;
 pub enum GroupId {
     Tmtc = 0,
     Hk = 1,
+    Mode = 2,
 }
 
 pub const OBSW_SERVER_ADDR: Ipv4Addr = Ipv4Addr::UNSPECIFIED;
@@ -37,6 +41,23 @@ pub const SERVER_PORT: u16 = 7301;
 pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> =
     EventU32TypedSev::<SeverityInfo>::const_new(0, 0);
 
+lazy_static! {
+    pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
+        let mut set = HashSet::new();
+        for id in components::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 components::Apid::iter() {
+            set.insert(id as u16);
+        }
+        set
+    };
+}
+
 pub mod tmtc_err {
 
     use super::*;
@@ -53,6 +74,8 @@ pub mod tmtc_err {
     pub const UNKNOWN_TARGET_ID: ResultU16 = ResultU16::new(GroupId::Tmtc as u8, 4);
     #[resultcode]
     pub const ROUTING_ERROR: ResultU16 = ResultU16::new(GroupId::Tmtc as u8, 5);
+    #[resultcode(info = "Request timeout for targeted PUS request. P1: Request ID. P2: Target ID")]
+    pub const REQUEST_TIMEOUT: ResultU16 = ResultU16::new(GroupId::Tmtc as u8, 6);
 
     #[resultcode(
         info = "Not enough data inside the TC application data field. Optionally includes: \
@@ -92,27 +115,70 @@ pub mod hk_err {
     ];
 }
 
-#[allow(clippy::enum_variant_names)]
+pub mod mode_err {
+    use super::*;
+
+    #[resultcode]
+    pub const WRONG_MODE: ResultU16 = ResultU16::new(GroupId::Mode as u8, 0);
+}
+
+pub mod components {
+    use satrs::request::UniqueApidTargetId;
+    use strum::EnumIter;
+
+    #[derive(Copy, Clone, PartialEq, Eq, EnumIter)]
+    pub enum Apid {
+        Sched = 1,
+        GenericPus = 2,
+        Acs = 3,
+        Cfdp = 4,
+        Tmtc = 5,
+    }
+
+    // Component IDs for components with the PUS APID.
     #[derive(Copy, Clone, PartialEq, Eq)]
-pub enum TmSenderId {
-    PusVerification = 0,
-    PusTest = 1,
-    PusEvent = 2,
-    PusHk = 3,
-    PusAction = 4,
-    PusSched = 5,
-    AllEvents = 6,
-    AcsSubsystem = 7,
+    pub enum PusId {
+        PusEventManagement = 0,
+        PusRouting = 1,
+        PusTest = 2,
+        PusAction = 3,
+        PusMode = 4,
+        PusHk = 5,
     }
 
     #[derive(Copy, Clone, PartialEq, Eq)]
-pub enum TcReceiverId {
-    PusTest = 1,
-    PusEvent = 2,
-    PusHk = 3,
-    PusAction = 4,
-    PusSched = 5,
+    pub enum AcsId {
+        Mgm0 = 0,
     }
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum TmtcId {
+        UdpServer = 0,
+        TcpServer = 1,
+    }
+
+    pub const PUS_ACTION_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusAction as u32);
+    pub const PUS_EVENT_MANAGEMENT: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, 0);
+    pub const PUS_ROUTING_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusRouting as u32);
+    pub const PUS_TEST_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusTest as u32);
+    pub const PUS_MODE_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusMode as u32);
+    pub const PUS_HK_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusHk as u32);
+    pub const PUS_SCHED_SERVICE: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Sched as u16, 0);
+    pub const MGM_HANDLER_0: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
+    pub const UDP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::UdpServer as u32);
+    pub const TCP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::TcpServer as u32);
+}
+
 pub mod pool {
     use super::*;
     pub fn create_static_pools() -> (StaticMemoryPool, StaticMemoryPool) {

satrs-example/src/events.rs

@@ -1,71 +1,87 @@
-use std::sync::mpsc::{self, SendError};
+use std::sync::mpsc::{self};
 
+use crate::pus::create_verification_reporter;
+use satrs::event_man::{EventMessageU32, EventRoutingError};
+use satrs::params::WritableToBeBytes;
+use satrs::pus::event::EventTmHookProvider;
+use satrs::pus::verification::VerificationReporter;
+use satrs::pus::EcssTmSender;
+use satrs::request::UniqueApidTargetId;
 use satrs::{
     event_man::{
-        EventManager, EventManagerWithMpscQueue, MpscEventReceiver, MpscEventU32SendProvider,
-        SendEventProvider,
+        EventManagerWithBoundedMpsc, EventSendProvider, EventU32SenderMpscBounded,
+        MpscEventReceiver,
     },
-    events::EventU32,
-    params::Params,
     pus::{
         event_man::{
-            DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
-            PusEventDispatcher,
+            DefaultPusEventU32Dispatcher, EventReporter, EventRequest, EventRequestWithToken,
         },
-        verification::{
-            TcStateStarted, VerificationReporterWithSender, VerificationReportingProvider,
-            VerificationToken,
+        verification::{TcStateStarted, VerificationReportingProvider, VerificationToken},
     },
-        EcssTmSender,
-    },
-    spacepackets::time::cds::{self, TimeProvider},
+    spacepackets::time::cds::CdsTime,
 };
-use satrs_example::config::PUS_APID;
+use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
 
 use crate::update_time;
 
-pub type MpscEventManager = EventManager<SendError<(EventU32, Option<Params>)>>;
-
-pub struct PusEventHandler {
-    event_request_rx: mpsc::Receiver<EventRequestWithToken>,
-    pus_event_dispatcher: PusEventDispatcher<(), EventU32>,
-    pus_event_man_rx: mpsc::Receiver<(EventU32, Option<Params>)>,
-    tm_sender: Box<dyn EcssTmSender>,
-    time_provider: TimeProvider,
-    timestamp: [u8; 7],
-    verif_handler: VerificationReporterWithSender,
+// This helper sets the APID of the event sender for the PUS telemetry.
+#[derive(Default)]
+pub struct EventApidSetter {
+    pub next_apid: u16,
 }
-/*
-*/
 
-impl PusEventHandler {
-    pub fn new(
-        verif_handler: VerificationReporterWithSender,
-        event_manager: &mut MpscEventManager,
+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> {
+    event_request_rx: mpsc::Receiver<EventRequestWithToken>,
+    pus_event_dispatcher: DefaultPusEventU32Dispatcher<()>,
+    pus_event_man_rx: mpsc::Receiver<EventMessageU32>,
+    tm_sender: TmSender,
+    time_provider: CdsTime,
+    timestamp: [u8; 7],
+    verif_handler: VerificationReporter,
+    event_apid_setter: EventApidSetter,
+}
+
+impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
+    pub fn new(
+        tm_sender: TmSender,
+        verif_handler: VerificationReporter,
+        event_manager: &mut EventManagerWithBoundedMpsc,
         event_request_rx: mpsc::Receiver<EventRequestWithToken>,
-        tm_sender: impl EcssTmSender,
     ) -> Self {
-        let (pus_event_man_tx, pus_event_man_rx) = mpsc::channel();
+        let event_queue_cap = 30;
+        let (pus_event_man_tx, pus_event_man_rx) = mpsc::sync_channel(event_queue_cap);
 
         // All events sent to the manager are routed to the PUS event manager, which generates PUS event
         // telemetry for each event.
-        let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
-        let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
+        let event_reporter = EventReporter::new(PUS_EVENT_MANAGEMENT.raw(), 0, 0, 128).unwrap();
         let pus_event_dispatcher =
-            PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
-        let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
+            DefaultPusEventU32Dispatcher::new_with_default_backend(event_reporter);
+        let pus_event_man_send_provider = EventU32SenderMpscBounded::new(
+            PUS_EVENT_MANAGEMENT.raw(),
+            pus_event_man_tx,
+            event_queue_cap,
+        );
 
-        event_manager.subscribe_all(pus_event_man_send_provider.id());
+        event_manager.subscribe_all(pus_event_man_send_provider.target_id());
         event_manager.add_sender(pus_event_man_send_provider);
 
         Self {
             event_request_rx,
             pus_event_dispatcher,
             pus_event_man_rx,
-            time_provider: cds::TimeProvider::new_with_u16_days(0, 0),
+            time_provider: CdsTime::new_with_u16_days(0, 0),
             timestamp: [0; 7],
             verif_handler,
-            tm_sender: Box::new(tm_sender),
+            tm_sender,
+            event_apid_setter: EventApidSetter::default(),
         }
     }
 
@@ -76,7 +92,7 @@ impl PusEventHandler {
                 .try_into()
                 .expect("expected start verification token");
             self.verif_handler
-                .completion_success(started_token, timestamp)
+                .completion_success(&self.tm_sender, started_token, timestamp)
                 .expect("Sending completion success failed");
         };
         // handle event requests
@@ -102,23 +118,29 @@ impl PusEventHandler {
 
     pub fn generate_pus_event_tm(&mut self) {
         // Perform the generation of PUS event packets
-        if let Ok((event, _param)) = self.pus_event_man_rx.try_recv() {
+        if let Ok(event_msg) = self.pus_event_man_rx.try_recv() {
             update_time(&mut self.time_provider, &mut self.timestamp);
+            let param_vec = event_msg.params().map_or(Vec::new(), |param| {
+                param.to_vec().expect("failed to convert params to vec")
+            });
+            self.event_apid_setter.next_apid = UniqueApidTargetId::from(event_msg.sender_id()).apid;
             self.pus_event_dispatcher
                 .generate_pus_event_tm_generic(
-                    self.tm_sender.upcast_mut(),
+                    &self.tm_sender,
                     &self.timestamp,
-                    event,
-                    None,
+                    event_msg.event(),
+                    Some(&param_vec),
                 )
                 .expect("Sending TM as event failed");
         }
     }
 }
 
+/// This is a thin wrapper around the event manager which also caches the sender component
+/// used to send events to the event manager.
 pub struct EventManagerWrapper {
-    event_manager: MpscEventManager,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    event_manager: EventManagerWithBoundedMpsc,
+    event_sender: mpsc::Sender<EventMessageU32>,
 }
 
 impl EventManagerWrapper {
@@ -126,46 +148,51 @@ impl EventManagerWrapper {
         // The sender handle is the primary sender handle for all components which want to create events.
         // The event manager will receive the RX handle to receive all the events.
         let (event_sender, event_man_rx) = mpsc::channel();
-        let event_recv = MpscEventReceiver::<EventU32>::new(event_man_rx);
+        let event_recv = MpscEventReceiver::new(event_man_rx);
         Self {
-            event_manager: EventManagerWithMpscQueue::new(Box::new(event_recv)),
+            event_manager: EventManagerWithBoundedMpsc::new(event_recv),
             event_sender,
         }
     }
 
-    pub fn clone_event_sender(&self) -> mpsc::Sender<(EventU32, Option<Params>)> {
+    // Returns a cached event sender to send events to the event manager for routing.
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
         self.event_sender.clone()
     }
 
-    pub fn event_manager(&mut self) -> &mut MpscEventManager {
+    pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
         &mut self.event_manager
     }
 
     pub fn try_event_routing(&mut self) {
+        let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| {
+            self.routing_error_handler(event_msg, error)
+        };
         // Perform the event routing.
-        self.event_manager
-            .try_event_handling()
-            .expect("event handling failed");
+        self.event_manager.try_event_handling(error_handler);
+    }
+
+    pub fn routing_error_handler(&self, event_msg: &EventMessageU32, error: EventRoutingError) {
+        log::warn!("event routing error for event {event_msg:?}: {error:?}");
     }
 }
 
-pub struct EventHandler {
+pub struct EventHandler<TmSender: EcssTmSender> {
     pub event_man_wrapper: EventManagerWrapper,
-    pub pus_event_handler: PusEventHandler,
+    pub pus_event_handler: PusEventHandler<TmSender>,
 }
 
-impl EventHandler {
+impl<TmSender: EcssTmSender> EventHandler<TmSender> {
     pub fn new(
-        tm_sender: impl EcssTmSender,
-        verif_handler: VerificationReporterWithSender,
+        tm_sender: TmSender,
         event_request_rx: mpsc::Receiver<EventRequestWithToken>,
     ) -> Self {
         let mut event_man_wrapper = EventManagerWrapper::new();
         let pus_event_handler = PusEventHandler::new(
-            verif_handler,
+            tm_sender,
+            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
             event_man_wrapper.event_manager(),
             event_request_rx,
-            tm_sender,
         );
         Self {
             event_man_wrapper,
@@ -173,12 +200,12 @@ impl EventHandler {
         }
     }
 
-    pub fn clone_event_sender(&self) -> mpsc::Sender<(EventU32, Option<Params>)> {
+    pub fn clone_event_sender(&self) -> mpsc::Sender<EventMessageU32> {
         self.event_man_wrapper.clone_event_sender()
     }
 
     #[allow(dead_code)]
-    pub fn event_manager(&mut self) -> &mut MpscEventManager {
+    pub fn event_manager(&mut self) -> &mut EventManagerWithBoundedMpsc {
         self.event_man_wrapper.event_manager()
     }
 

satrs-example/src/hk.rs

@@ -1,27 +1,25 @@
 use derive_new::new;
+use satrs::hk::UniqueId;
+use satrs::request::UniqueApidTargetId;
 use satrs::spacepackets::ByteConversionError;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum AcsHkIds {
-    TestMgmSet = 1,
-}
-
 #[derive(Debug, new, Copy, Clone)]
 pub struct HkUniqueId {
-    target_id: u32,
-    set_id: u32,
+    target_id: UniqueApidTargetId,
+    set_id: UniqueId,
 }
 
 impl HkUniqueId {
     #[allow(dead_code)]
-    pub fn target_id(&self) -> u32 {
+    pub fn target_id(&self) -> UniqueApidTargetId {
         self.target_id
     }
     #[allow(dead_code)]
-    pub fn set_id(&self) -> u32 {
+    pub fn set_id(&self) -> UniqueId {
         self.set_id
     }
 
+    #[allow(dead_code)]
     pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < 8 {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -29,7 +27,7 @@ impl HkUniqueId {
                 expected: 8,
             });
         }
-        buf[0..4].copy_from_slice(&self.target_id.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)

satrs-example/src/interface/mod.rs

@@ -0,0 +1,3 @@
+//! This module contains all component related to the direct interface of the example.
+pub mod tcp;
+pub mod udp;

satrs-example/src/interface/tcp.rs

@@ -1,17 +1,49 @@
 use std::{
-    collections::VecDeque,
+    collections::{HashSet, VecDeque},
+    fmt::Debug,
+    marker::PhantomData,
     sync::{Arc, Mutex},
 };
 
 use log::{info, warn};
 use satrs::{
-    hal::std::tcp_server::{ServerConfig, TcpSpacepacketsServer},
-    spacepackets::PacketId,
-    tmtc::{CcsdsDistributor, CcsdsError, TmPacketSourceCore},
+    encoding::ccsds::{SpValidity, SpacePacketValidator},
+    hal::std::tcp_server::{HandledConnectionHandler, ServerConfig, TcpSpacepacketsServer},
+    spacepackets::{CcsdsPacket, PacketId},
+    tmtc::{PacketSenderRaw, PacketSource},
 };
-use satrs_example::config::PUS_APID;
 
-pub const PACKET_ID_LOOKUP: &[PacketId] = &[PacketId::const_tc(true, PUS_APID)];
+#[derive(Default)]
+pub struct ConnectionFinishedHandler {}
+
+pub struct SimplePacketValidator {
+    pub valid_ids: HashSet<PacketId>,
+}
+
+impl SpacePacketValidator for SimplePacketValidator {
+    fn validate(
+        &self,
+        sp_header: &satrs::spacepackets::SpHeader,
+        _raw_buf: &[u8],
+    ) -> satrs::encoding::ccsds::SpValidity {
+        if self.valid_ids.contains(&sp_header.packet_id()) {
+            return SpValidity::Valid;
+        }
+        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
+    }
+}
+
+impl HandledConnectionHandler for ConnectionFinishedHandler {
+    fn handled_connection(&mut self, info: satrs::hal::std::tcp_server::HandledConnectionInfo) {
+        info!(
+            "Served {} TMs and {} TCs for client {:?}",
+            info.num_sent_tms, info.num_received_tcs, info.addr
+        );
+    }
+}
 
 #[derive(Default, Clone)]
 pub struct SyncTcpTmSource {
@@ -41,7 +73,7 @@ impl SyncTcpTmSource {
     }
 }
 
-impl TmPacketSourceCore for SyncTcpTmSource {
+impl PacketSource for SyncTcpTmSource {
     type Error = ();
 
     fn retrieve_packet(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
@@ -69,41 +101,47 @@ impl TmPacketSourceCore for SyncTcpTmSource {
     }
 }
 
-pub struct TcpTask<MpscErrorType: 'static> {
-    server: TcpSpacepacketsServer<
-        (),
-        CcsdsError<MpscErrorType>,
+pub type TcpServer<ReceivesTc, SendError> = TcpSpacepacketsServer<
     SyncTcpTmSource,
-        CcsdsDistributor<MpscErrorType>,
-    >,
-}
+    ReceivesTc,
+    SimplePacketValidator,
+    ConnectionFinishedHandler,
+    (),
+    SendError,
+>;
 
-impl<MpscErrorType: 'static + core::fmt::Debug> TcpTask<MpscErrorType> {
+pub struct TcpTask<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>(
+    pub TcpServer<TcSender, SendError>,
+    PhantomData<SendError>,
+);
+
+impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>
+    TcpTask<TcSender, SendError>
+{
     pub fn new(
         cfg: ServerConfig,
         tm_source: SyncTcpTmSource,
-        tc_receiver: CcsdsDistributor<MpscErrorType>,
+        tc_sender: TcSender,
+        valid_ids: HashSet<PacketId>,
     ) -> Result<Self, std::io::Error> {
-        Ok(Self {
-            server: TcpSpacepacketsServer::new(
+        Ok(Self(
+            TcpSpacepacketsServer::new(
                 cfg,
                 tm_source,
-                tc_receiver,
-                Box::new(PACKET_ID_LOOKUP),
+                tc_sender,
+                SimplePacketValidator { valid_ids },
+                ConnectionFinishedHandler::default(),
+                None,
             )?,
-        })
+            PhantomData,
+        ))
     }
 
     pub fn periodic_operation(&mut self) {
         loop {
-            let result = self.server.handle_next_connection();
+            let result = self.0.handle_all_connections(None);
             match result {
-                Ok(conn_result) => {
-                    info!(
-                        "Served {} TMs and {} TCs for client {:?}",
-                        conn_result.num_sent_tms, conn_result.num_received_tcs, conn_result.addr
-                    );
-                }
+                Ok(_conn_result) => (),
                 Err(e) => {
                     warn!("TCP server error: {e:?}");
                 }

satrs-example/src/interface/udp.rs

@@ -1,34 +1,35 @@
-use std::{
-    net::{SocketAddr, UdpSocket},
-    sync::mpsc::Receiver,
-};
+use core::fmt::Debug;
+use std::net::{SocketAddr, UdpSocket};
+use std::sync::mpsc;
 
 use log::{info, warn};
+use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderRaw};
 use satrs::{
     hal::std::udp_server::{ReceiveResult, UdpTcServer},
-    pool::{PoolProviderWithGuards, SharedStaticMemoryPool, StoreAddr},
-    tmtc::CcsdsError,
+    pool::{PoolProviderWithGuards, SharedStaticMemoryPool},
 };
 
+use crate::pus::HandlingStatus;
+
 pub trait UdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }
 
 pub struct StaticUdpTmHandler {
-    pub tm_rx: Receiver<StoreAddr>,
+    pub tm_rx: mpsc::Receiver<PacketInPool>,
     pub tm_store: SharedStaticMemoryPool,
 }
 
 impl UdpTmHandler for StaticUdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, &recv_addr: &SocketAddr) {
-        while let Ok(addr) = self.tm_rx.try_recv() {
+        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(addr);
+            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");
@@ -44,20 +45,20 @@ impl UdpTmHandler for StaticUdpTmHandler {
 }
 
 pub struct DynamicUdpTmHandler {
-    pub tm_rx: Receiver<Vec<u8>>,
+    pub tm_rx: mpsc::Receiver<PacketAsVec>,
 }
 
 impl UdpTmHandler for DynamicUdpTmHandler {
     fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr) {
         while let Ok(tm) = self.tm_rx.try_recv() {
-            if tm.len() > 9 {
-                let service = tm[7];
-                let subservice = tm[8];
+            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, recv_addr);
+            let result = socket.send_to(&tm.packet, recv_addr);
             if let Err(e) = result {
                 warn!("Sending TM with UDP socket failed: {e}")
             }
@@ -65,42 +66,48 @@ impl UdpTmHandler for DynamicUdpTmHandler {
     }
 }
 
-pub struct UdpTmtcServer<TmHandler: UdpTmHandler, SendError> {
-    pub udp_tc_server: UdpTcServer<CcsdsError<SendError>>,
+pub struct UdpTmtcServer<
+    TcSender: PacketSenderRaw<Error = SendError>,
+    TmHandler: UdpTmHandler,
+    SendError,
+> {
+    pub udp_tc_server: UdpTcServer<TcSender, SendError>,
     pub tm_handler: TmHandler,
 }
 
-impl<TmHandler: UdpTmHandler, SendError: core::fmt::Debug + 'static>
-    UdpTmtcServer<TmHandler, SendError>
+impl<
+        TcSender: PacketSenderRaw<Error = SendError>,
+        TmHandler: UdpTmHandler,
+        SendError: Debug + 'static,
+    > UdpTmtcServer<TcSender, TmHandler, SendError>
 {
     pub fn periodic_operation(&mut self) {
-        while self.poll_tc_server() {}
+        loop {
+            if self.poll_tc_server() == HandlingStatus::Empty {
+                break;
+            }
+        }
         if let Some(recv_addr) = self.udp_tc_server.last_sender() {
             self.tm_handler
                 .send_tm_to_udp_client(&self.udp_tc_server.socket, &recv_addr);
         }
     }
 
-    fn poll_tc_server(&mut self) -> bool {
+    fn poll_tc_server(&mut self) -> HandlingStatus {
         match self.udp_tc_server.try_recv_tc() {
-            Ok(_) => true,
-            Err(e) => match e {
-                ReceiveResult::ReceiverError(e) => match e {
-                    CcsdsError::ByteConversionError(e) => {
-                        warn!("packet error: {e:?}");
-                        true
-                    }
-                    CcsdsError::CustomError(e) => {
-                        warn!("mpsc custom error {e:?}");
-                        true
-                    }
-                },
-                ReceiveResult::IoError(e) => {
+            Ok(_) => HandlingStatus::HandledOne,
+            Err(e) => {
+                match e {
+                    ReceiveResult::NothingReceived => (),
+                    ReceiveResult::Io(e) => {
                         warn!("IO error {e}");
-                    false
                     }
-                ReceiveResult::NothingReceived => false,
-            },
+                    ReceiveResult::Send(send_error) => {
+                        warn!("send error {send_error:?}");
+                    }
+                }
+                HandlingStatus::Empty
+            }
         }
     }
 }
@@ -108,6 +115,7 @@ impl<TmHandler: UdpTmHandler, SendError: core::fmt::Debug + 'static>
 #[cfg(test)]
 mod tests {
     use std::{
+        cell::RefCell,
         collections::VecDeque,
         net::IpAddr,
         sync::{Arc, Mutex},
@@ -118,21 +126,26 @@ mod tests {
             ecss::{tc::PusTcCreator, WritablePusPacket},
             SpHeader,
         },
-        tmtc::ReceivesTcCore,
+        tmtc::PacketSenderRaw,
+        ComponentId,
     };
-    use satrs_example::config::{OBSW_SERVER_ADDR, PUS_APID};
+    use satrs_example::config::{components, OBSW_SERVER_ADDR};
 
     use super::*;
 
-    #[derive(Default, Debug, Clone)]
-    pub struct TestReceiver {
-        tc_vec: Arc<Mutex<VecDeque<Vec<u8>>>>,
+    const UDP_SERVER_ID: ComponentId = 0x05;
+
+    #[derive(Default, Debug)]
+    pub struct TestSender {
+        tc_vec: RefCell<VecDeque<PacketAsVec>>,
     }
 
-    impl ReceivesTcCore for TestReceiver {
-        type Error = CcsdsError<()>;
-        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-            self.tc_vec.lock().unwrap().push_back(tc_raw.to_vec());
+    impl PacketSenderRaw for TestSender {
+        type Error = ();
+
+        fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+            let mut mut_queue = self.tc_vec.borrow_mut();
+            mut_queue.push_back(PacketAsVec::new(sender_id, tc_raw.to_vec()));
             Ok(())
         }
     }
@@ -151,9 +164,10 @@ mod tests {
     #[test]
     fn test_basic() {
         let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
-        let test_receiver = TestReceiver::default();
-        let tc_queue = test_receiver.tc_vec.clone();
-        let udp_tc_server = UdpTcServer::new(sock_addr, 2048, Box::new(test_receiver)).unwrap();
+        let test_receiver = TestSender::default();
+        // let tc_queue = test_receiver.tc_vec.clone();
+        let udp_tc_server =
+            UdpTcServer::new(UDP_SERVER_ID, sock_addr, 2048, test_receiver).unwrap();
         let tm_handler = TestTmHandler::default();
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
         let mut udp_dyn_server = UdpTmtcServer {
@@ -161,16 +175,18 @@ mod tests {
             tm_handler,
         };
         udp_dyn_server.periodic_operation();
-        assert!(tc_queue.lock().unwrap().is_empty());
+        let queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow();
+        assert!(queue.is_empty());
         assert!(tm_handler_calls.lock().unwrap().is_empty());
     }
 
     #[test]
     fn test_transactions() {
         let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), 0);
-        let test_receiver = TestReceiver::default();
-        let tc_queue = test_receiver.tc_vec.clone();
-        let udp_tc_server = UdpTcServer::new(sock_addr, 2048, Box::new(test_receiver)).unwrap();
+        let test_receiver = TestSender::default();
+        // let tc_queue = test_receiver.tc_vec.clone();
+        let udp_tc_server =
+            UdpTcServer::new(UDP_SERVER_ID, sock_addr, 2048, test_receiver).unwrap();
         let server_addr = udp_tc_server.socket.local_addr().unwrap();
         let tm_handler = TestTmHandler::default();
         let tm_handler_calls = tm_handler.addrs_to_send_to.clone();
@@ -178,8 +194,8 @@ mod tests {
             udp_tc_server,
             tm_handler,
         };
-        let mut sph = SpHeader::tc_unseg(PUS_APID, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true)
+        let sph = SpHeader::new_for_unseg_tc(components::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");
@@ -188,10 +204,11 @@ mod tests {
         client.send(&ping_tc).unwrap();
         udp_dyn_server.periodic_operation();
         {
-            let mut tc_queue = tc_queue.lock().unwrap();
-            assert!(!tc_queue.is_empty());
-            let received_tc = tc_queue.pop_front().unwrap();
-            assert_eq!(received_tc, ping_tc);
+            let mut queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow_mut();
+            assert!(!queue.is_empty());
+            let packet_with_sender = queue.pop_front().unwrap();
+            assert_eq!(packet_with_sender.packet, ping_tc);
+            assert_eq!(packet_with_sender.sender_id, UDP_SERVER_ID);
         }
 
         {
@@ -202,7 +219,9 @@ mod tests {
             assert_eq!(received_addr, client_addr);
         }
         udp_dyn_server.periodic_operation();
-        assert!(tc_queue.lock().unwrap().is_empty());
+        let queue = udp_dyn_server.udp_tc_server.tc_sender.tc_vec.borrow();
+        assert!(queue.is_empty());
+        drop(queue);
         // Still tries to send to the same client.
         {
             let mut tm_handler_calls = tm_handler_calls.lock().unwrap();

satrs-example/src/lib.rs

@@ -1 +1,39 @@
+use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};
+
 pub mod config;
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum DeviceMode {
+    Off = 0,
+    On = 1,
+    Normal = 2,
+}
+
+pub struct TimeStampHelper {
+    stamper: CdsTime,
+    time_stamp: [u8; 7],
+}
+
+impl TimeStampHelper {
+    pub fn stamp(&self) -> &[u8] {
+        &self.time_stamp
+    }
+
+    pub fn update_from_now(&mut self) {
+        self.stamper
+            .update_from_now()
+            .expect("Updating timestamp failed");
+        self.stamper
+            .write_to_bytes(&mut self.time_stamp)
+            .expect("Writing timestamp failed");
+    }
+}
+
+impl Default for TimeStampHelper {
+    fn default() -> Self {
+        Self {
+            stamper: CdsTime::now_with_u16_days().expect("creating time stamper failed"),
+            time_stamp: Default::default(),
+        }
+    }
+}

satrs-example/src/main.rs

@@ -1,98 +1,81 @@
 mod acs;
-mod ccsds;
 mod events;
 mod hk;
+mod interface;
 mod logger;
 mod pus;
 mod requests;
-mod tcp;
-mod tm_funnel;
 mod tmtc;
-mod udp;
 
 use crate::events::EventHandler;
+use crate::interface::udp::DynamicUdpTmHandler;
 use crate::pus::stack::PusStack;
-use crate::tm_funnel::{TmFunnelDynamic, TmFunnelStatic};
+use crate::tmtc::tc_source::{TcSourceTaskDynamic, TcSourceTaskStatic};
+use crate::tmtc::tm_sink::{TmFunnelDynamic, TmFunnelStatic};
 use log::info;
 use pus::test::create_test_service_dynamic;
 use satrs::hal::std::tcp_server::ServerConfig;
 use satrs::hal::std::udp_server::UdpTcServer;
-use satrs::request::TargetAndApidId;
-use satrs::tmtc::tm_helper::SharedTmPool;
+use satrs::request::GenericMessage;
+use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
 use satrs_example::config::pool::{create_sched_tc_pool, create_static_pools};
 use satrs_example::config::tasks::{
     FREQ_MS_AOCS, FREQ_MS_EVENT_HANDLING, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC,
 };
-use satrs_example::config::{RequestTargetId, TmSenderId, OBSW_SERVER_ADDR, PUS_APID, SERVER_PORT};
-use tmtc::PusTcSourceProviderDynamic;
-use udp::DynamicUdpTmHandler;
+use satrs_example::config::{OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT};
 
-use crate::acs::AcsTask;
-use crate::ccsds::CcsdsReceiver;
+use crate::acs::mgm::{MgmHandlerLis3Mdl, MpscModeLeafInterface, SpiDummyInterface};
+use crate::interface::tcp::{SyncTcpTmSource, TcpTask};
+use crate::interface::udp::{StaticUdpTmHandler, UdpTmtcServer};
 use crate::logger::setup_logger;
 use crate::pus::action::{create_action_service_dynamic, create_action_service_static};
 use crate::pus::event::{create_event_service_dynamic, create_event_service_static};
 use crate::pus::hk::{create_hk_service_dynamic, create_hk_service_static};
+use crate::pus::mode::{create_mode_service_dynamic, create_mode_service_static};
 use crate::pus::scheduler::{create_scheduler_service_dynamic, create_scheduler_service_static};
 use crate::pus::test::create_test_service_static;
-use crate::pus::{PusReceiver, PusTcMpscRouter};
-use crate::requests::{GenericRequestRouter, RequestWithToken};
-use crate::tcp::{SyncTcpTmSource, TcpTask};
-use crate::tmtc::{
-    PusTcSourceProviderSharedPool, SharedTcPool, TcSourceTaskDynamic, TcSourceTaskStatic,
-};
-use crate::udp::{StaticUdpTmHandler, UdpTmtcServer};
+use crate::pus::{PusTcDistributor, PusTcMpscRouter};
+use crate::requests::{CompositeRequest, GenericRequestRouter};
+use satrs::mode::ModeRequest;
 use satrs::pus::event_man::EventRequestWithToken;
-use satrs::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
-use satrs::pus::{EcssTmSender, MpscTmAsVecSender, MpscTmInSharedPoolSender};
-use satrs::spacepackets::{time::cds::TimeProvider, time::TimeWriter};
-use satrs::tmtc::CcsdsDistributor;
-use satrs::ChannelId;
+use satrs::spacepackets::{time::cds::CdsTime, time::TimeWriter};
+use satrs_example::config::components::{MGM_HANDLER_0, TCP_SERVER, UDP_SERVER};
 use std::net::{IpAddr, SocketAddr};
-use std::sync::mpsc::{self, channel};
+use std::sync::mpsc;
 use std::sync::{Arc, RwLock};
 use std::thread;
 use std::time::Duration;
 
-fn create_verification_reporter(verif_sender: impl EcssTmSender) -> VerificationReporterWithSender {
-    let verif_cfg = VerificationReporterCfg::new(PUS_APID, 1, 2, 8).unwrap();
-    // Every software component which needs to generate verification telemetry, gets a cloned
-    // verification reporter.
-    VerificationReporterWithSender::new(&verif_cfg, Box::new(verif_sender))
-}
-
 #[allow(dead_code)]
 fn static_tmtc_pool_main() {
     let (tm_pool, tc_pool) = create_static_pools();
-    let shared_tm_pool = SharedTmPool::new(tm_pool);
-    let shared_tc_pool = SharedTcPool {
-        pool: Arc::new(RwLock::new(tc_pool)),
-    };
-    let (tc_source_tx, tc_source_rx) = channel();
-    let (tm_funnel_tx, tm_funnel_rx) = channel();
-    let (tm_server_tx, tm_server_rx) = channel();
+    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_funnel_tx, tm_funnel_rx) = mpsc::sync_channel(50);
+    let (tm_server_tx, tm_server_rx) = mpsc::sync_channel(50);
 
-    // Every software component which needs to generate verification telemetry, receives a cloned
-    // verification reporter.
-    let verif_reporter = create_verification_reporter(MpscTmInSharedPoolSender::new(
-        TmSenderId::PusVerification as ChannelId,
-        "verif_sender",
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-    ));
+    let tm_funnel_tx_sender =
+        PacketSenderWithSharedPool::new(tm_funnel_tx.clone(), shared_tm_pool_wrapper.clone());
+
+    let (mgm_handler_composite_tx, mgm_handler_composite_rx) =
+        mpsc::channel::<GenericMessage<CompositeRequest>>();
+    let (mgm_handler_mode_tx, mgm_handler_mode_rx) = mpsc::channel::<GenericMessage<ModeRequest>>();
 
-    let acs_target_id = TargetAndApidId::new(PUS_APID, RequestTargetId::AcsSubsystem as u32);
-    let (acs_thread_tx, acs_thread_rx) = channel::<RequestWithToken>();
     // 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.0.insert(acs_target_id.into(), acs_thread_tx);
+    request_map
+        .composite_router_map
+        .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
+    request_map
+        .mode_router_map
+        .insert(MGM_HANDLER_0.id(), mgm_handler_mode_tx);
 
     // This helper structure is used by all telecommand providers which need to send telecommands
     // to the TC source.
-    let tc_source = PusTcSourceProviderSharedPool {
-        shared_pool: shared_tc_pool.clone(),
-        tc_source: tc_source_tx,
-    };
+    let tc_source = PacketSenderWithSharedPool::new(tc_source_tx, shared_tc_pool_wrapper.clone());
 
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
@@ -101,127 +84,139 @@ fn static_tmtc_pool_main() {
 
     // 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(
-        MpscTmInSharedPoolSender::new(
-            TmSenderId::AllEvents as ChannelId,
-            "ALL_EVENTS_TX",
-            shared_tm_pool.clone(),
-            tm_funnel_tx.clone(),
-        ),
-        verif_reporter.clone(),
-        event_request_rx,
-    );
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
+
+    let (pus_test_tx, pus_test_rx) = mpsc::channel();
+    let (pus_event_tx, pus_event_rx) = mpsc::channel();
+    let (pus_sched_tx, pus_sched_rx) = mpsc::channel();
+    let (pus_hk_tx, pus_hk_rx) = mpsc::channel();
+    let (pus_action_tx, pus_action_rx) = mpsc::channel();
+    let (pus_mode_tx, pus_mode_rx) = mpsc::channel();
+
+    let (_pus_action_reply_tx, pus_action_reply_rx) = mpsc::channel();
+    let (pus_hk_reply_tx, pus_hk_reply_rx) = mpsc::channel();
+    let (pus_mode_reply_tx, pus_mode_reply_rx) = mpsc::channel();
 
-    let (pus_test_tx, pus_test_rx) = channel();
-    let (pus_event_tx, pus_event_rx) = channel();
-    let (pus_sched_tx, pus_sched_rx) = channel();
-    let (pus_hk_tx, pus_hk_rx) = channel();
-    let (pus_action_tx, pus_action_rx) = channel();
     let pus_router = PusTcMpscRouter {
-        test_service_receiver: pus_test_tx,
-        event_service_receiver: pus_event_tx,
-        sched_service_receiver: pus_sched_tx,
-        hk_service_receiver: pus_hk_tx,
-        action_service_receiver: pus_action_tx,
+        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_static(
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        shared_tc_pool.pool.clone(),
+        tm_funnel_tx_sender.clone(),
+        shared_tc_pool.clone(),
         event_handler.clone_event_sender(),
         pus_test_rx,
     );
     let pus_scheduler_service = create_scheduler_service_static(
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
+        tm_funnel_tx_sender.clone(),
         tc_source.clone(),
         pus_sched_rx,
         create_sched_tc_pool(),
     );
     let pus_event_service = create_event_service_static(
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        shared_tc_pool.pool.clone(),
+        tm_funnel_tx_sender.clone(),
+        shared_tc_pool.clone(),
         pus_event_rx,
         event_request_tx,
     );
     let pus_action_service = create_action_service_static(
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        shared_tc_pool.pool.clone(),
+        tm_funnel_tx_sender.clone(),
+        shared_tc_pool.clone(),
         pus_action_rx,
         request_map.clone(),
+        pus_action_reply_rx,
     );
     let pus_hk_service = create_hk_service_static(
-        shared_tm_pool.clone(),
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        shared_tc_pool.pool.clone(),
+        tm_funnel_tx_sender.clone(),
+        shared_tc_pool.clone(),
         pus_hk_rx,
+        request_map.clone(),
+        pus_hk_reply_rx,
+    );
+    let pus_mode_service = create_mode_service_static(
+        tm_funnel_tx_sender.clone(),
+        shared_tc_pool.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_test_service,
+        pus_mode_service,
     );
 
-    let ccsds_receiver = CcsdsReceiver { tc_source };
     let mut tmtc_task = TcSourceTaskStatic::new(
-        shared_tc_pool.clone(),
+        shared_tc_pool_wrapper.clone(),
         tc_source_rx,
-        PusReceiver::new(verif_reporter.clone(), pus_router),
+        PusTcDistributor::new(tm_funnel_tx_sender, pus_router),
     );
 
     let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let udp_ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver.clone()));
-    let udp_tc_server = UdpTcServer::new(sock_addr, 2048, Box::new(udp_ccsds_distributor))
+    let udp_tc_server = UdpTcServer::new(UDP_SERVER.id(), sock_addr, 2048, tc_source.clone())
         .expect("creating UDP TMTC server failed");
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
         tm_handler: StaticUdpTmHandler {
             tm_rx: tm_server_rx,
-            tm_store: shared_tm_pool.clone_backing_pool(),
+            tm_store: shared_tm_pool.clone(),
         },
     };
 
-    let tcp_ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver));
-    let tcp_server_cfg = ServerConfig::new(sock_addr, Duration::from_millis(400), 4096, 8192);
+    let tcp_server_cfg = ServerConfig::new(
+        TCP_SERVER.id(),
+        sock_addr,
+        Duration::from_millis(400),
+        4096,
+        8192,
+    );
     let sync_tm_tcp_source = SyncTcpTmSource::new(200);
     let mut tcp_server = TcpTask::new(
         tcp_server_cfg,
         sync_tm_tcp_source.clone(),
-        tcp_ccsds_distributor,
+        tc_source.clone(),
+        PACKET_ID_VALIDATOR.clone(),
     )
     .expect("tcp server creation failed");
 
-    let mut acs_task = AcsTask::new(
-        MpscTmInSharedPoolSender::new(
-            TmSenderId::AcsSubsystem as ChannelId,
-            "ACS_TASK_SENDER",
-            shared_tm_pool.clone(),
-            tm_funnel_tx.clone(),
-        ),
-        acs_thread_rx,
-        verif_reporter,
-    );
-
     let mut tm_funnel = TmFunnelStatic::new(
-        shared_tm_pool,
+        shared_tm_pool_wrapper,
         sync_tm_tcp_source,
         tm_funnel_rx,
         tm_server_tx,
     );
 
+    let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) =
+        mpsc::channel();
+
+    let dummy_spi_interface = SpiDummyInterface::default();
+    let shared_mgm_set = Arc::default();
+    let mode_leaf_interface = MpscModeLeafInterface {
+        request_rx: mgm_handler_mode_rx,
+        reply_tx_to_pus: pus_mode_reply_tx,
+        reply_tx_to_parent: mgm_handler_mode_reply_to_parent_tx,
+    };
+    let mut mgm_handler = MgmHandlerLis3Mdl::new(
+        MGM_HANDLER_0,
+        "MGM_0",
+        mode_leaf_interface,
+        mgm_handler_composite_rx,
+        pus_hk_reply_tx,
+        tm_funnel_tx,
+        dummy_spi_interface,
+        shared_mgm_set,
+    );
+
     info!("Starting TMTC and UDP task");
     let jh_udp_tmtc = thread::Builder::new()
-        .name("TMTC and UDP".to_string())
+        .name("SATRS tmtc-udp".to_string())
         .spawn(move || {
             info!("Running UDP server on port {SERVER_PORT}");
             loop {
@@ -234,7 +229,7 @@ fn static_tmtc_pool_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 {
@@ -253,7 +248,7 @@ fn static_tmtc_pool_main() {
 
     info!("Starting event handling task");
     let jh_event_handling = thread::Builder::new()
-        .name("Event".to_string())
+        .name("sat-rs events".to_string())
         .spawn(move || loop {
             event_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_EVENT_HANDLING));
@@ -262,16 +257,16 @@ fn static_tmtc_pool_main() {
 
     info!("Starting AOCS thread");
     let jh_aocs = thread::Builder::new()
-        .name("AOCS".to_string())
+        .name("sat-rs aocs".to_string())
         .spawn(move || loop {
-            acs_task.periodic_operation();
+            mgm_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();
 
     info!("Starting PUS handler thread");
     let jh_pus_handler = thread::Builder::new()
-        .name("PUS".to_string())
+        .name("sat-rs pus".to_string())
         .spawn(move || loop {
             pus_stack.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_PUS_STACK));
@@ -298,24 +293,23 @@ fn static_tmtc_pool_main() {
 
 #[allow(dead_code)]
 fn dyn_tmtc_pool_main() {
-    let (tc_source_tx, tc_source_rx) = channel();
-    let (tm_funnel_tx, tm_funnel_rx) = channel();
-    let (tm_server_tx, tm_server_rx) = channel();
-    // Every software component which needs to generate verification telemetry, gets a cloned
-    // verification reporter.
-    let verif_reporter = create_verification_reporter(MpscTmAsVecSender::new(
-        TmSenderId::PusVerification as ChannelId,
-        "verif_sender",
-        tm_funnel_tx.clone(),
-    ));
+    let (tc_source_tx, tc_source_rx) = mpsc::channel();
+    let (tm_funnel_tx, tm_funnel_rx) = mpsc::channel();
+    let (tm_server_tx, tm_server_rx) = mpsc::channel();
+
+    // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
+    let (mgm_handler_composite_tx, mgm_handler_composite_rx) =
+        mpsc::channel::<GenericMessage<CompositeRequest>>();
+    let (mgm_handler_mode_tx, mgm_handler_mode_rx) = mpsc::channel::<GenericMessage<ModeRequest>>();
 
-    let acs_target_id = TargetAndApidId::new(PUS_APID, RequestTargetId::AcsSubsystem as u32);
-    let (acs_thread_tx, acs_thread_rx) = channel::<RequestWithToken>();
     // 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.0.insert(acs_target_id.into(), acs_thread_tx);
-
-    let tc_source = PusTcSourceProviderDynamic(tc_source_tx);
+    request_map
+        .composite_router_map
+        .insert(MGM_HANDLER_0.raw(), mgm_handler_composite_tx);
+    request_map
+        .mode_router_map
+        .insert(MGM_HANDLER_0.raw(), mgm_handler_mode_tx);
 
     // Create event handling components
     // These sender handles are used to send event requests, for example to enable or disable
@@ -323,79 +317,76 @@ fn dyn_tmtc_pool_main() {
     let (event_request_tx, event_request_rx) = mpsc::channel::<EventRequestWithToken>();
     // 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(
-        MpscTmAsVecSender::new(
-            TmSenderId::AllEvents as ChannelId,
-            "ALL_EVENTS_TX",
-            tm_funnel_tx.clone(),
-        ),
-        verif_reporter.clone(),
-        event_request_rx,
-    );
+    let mut event_handler = EventHandler::new(tm_funnel_tx.clone(), event_request_rx);
+
+    let (pus_test_tx, pus_test_rx) = mpsc::channel();
+    let (pus_event_tx, pus_event_rx) = mpsc::channel();
+    let (pus_sched_tx, pus_sched_rx) = mpsc::channel();
+    let (pus_hk_tx, pus_hk_rx) = mpsc::channel();
+    let (pus_action_tx, pus_action_rx) = mpsc::channel();
+    let (pus_mode_tx, pus_mode_rx) = mpsc::channel();
+
+    let (_pus_action_reply_tx, pus_action_reply_rx) = mpsc::channel();
+    let (pus_hk_reply_tx, pus_hk_reply_rx) = mpsc::channel();
+    let (pus_mode_reply_tx, pus_mode_reply_rx) = mpsc::channel();
 
-    let (pus_test_tx, pus_test_rx) = channel();
-    let (pus_event_tx, pus_event_rx) = channel();
-    let (pus_sched_tx, pus_sched_rx) = channel();
-    let (pus_hk_tx, pus_hk_rx) = channel();
-    let (pus_action_tx, pus_action_rx) = channel();
     let pus_router = PusTcMpscRouter {
-        test_service_receiver: pus_test_tx,
-        event_service_receiver: pus_event_tx,
-        sched_service_receiver: pus_sched_tx,
-        hk_service_receiver: pus_hk_tx,
-        action_service_receiver: pus_action_tx,
+        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_dynamic(
         tm_funnel_tx.clone(),
-        verif_reporter.clone(),
         event_handler.clone_event_sender(),
         pus_test_rx,
     );
     let pus_scheduler_service = create_scheduler_service_dynamic(
         tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        tc_source.0.clone(),
+        tc_source_tx.clone(),
         pus_sched_rx,
         create_sched_tc_pool(),
     );
 
-    let pus_event_service = create_event_service_dynamic(
-        tm_funnel_tx.clone(),
-        verif_reporter.clone(),
-        pus_event_rx,
-        event_request_tx,
-    );
+    let pus_event_service =
+        create_event_service_dynamic(tm_funnel_tx.clone(), pus_event_rx, event_request_tx);
     let pus_action_service = create_action_service_dynamic(
         tm_funnel_tx.clone(),
-        verif_reporter.clone(),
         pus_action_rx,
         request_map.clone(),
+        pus_action_reply_rx,
     );
     let pus_hk_service = create_hk_service_dynamic(
         tm_funnel_tx.clone(),
-        verif_reporter.clone(),
         pus_hk_rx,
+        request_map.clone(),
+        pus_hk_reply_rx,
+    );
+    let pus_mode_service = create_mode_service_dynamic(
+        tm_funnel_tx.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_test_service,
+        pus_mode_service,
     );
 
-    let ccsds_receiver = CcsdsReceiver { tc_source };
-
     let mut tmtc_task = TcSourceTaskDynamic::new(
         tc_source_rx,
-        PusReceiver::new(verif_reporter.clone(), pus_router),
+        PusTcDistributor::new(tm_funnel_tx.clone(), pus_router),
     );
 
     let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let udp_ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver.clone()));
-    let udp_tc_server = UdpTcServer::new(sock_addr, 2048, Box::new(udp_ccsds_distributor))
+    let udp_tc_server = UdpTcServer::new(UDP_SERVER.id(), sock_addr, 2048, tc_source_tx.clone())
         .expect("creating UDP TMTC server failed");
     let mut udp_tmtc_server = UdpTmtcServer {
         udp_tc_server,
@@ -404,30 +395,47 @@ fn dyn_tmtc_pool_main() {
         },
     };
 
-    let tcp_ccsds_distributor = CcsdsDistributor::new(Box::new(ccsds_receiver));
-    let tcp_server_cfg = ServerConfig::new(sock_addr, Duration::from_millis(400), 4096, 8192);
+    let tcp_server_cfg = ServerConfig::new(
+        TCP_SERVER.id(),
+        sock_addr,
+        Duration::from_millis(400),
+        4096,
+        8192,
+    );
     let sync_tm_tcp_source = SyncTcpTmSource::new(200);
     let mut tcp_server = TcpTask::new(
         tcp_server_cfg,
         sync_tm_tcp_source.clone(),
-        tcp_ccsds_distributor,
+        tc_source_tx.clone(),
+        PACKET_ID_VALIDATOR.clone(),
     )
     .expect("tcp server creation failed");
 
-    let mut acs_task = AcsTask::new(
-        MpscTmAsVecSender::new(
-            TmSenderId::AcsSubsystem as ChannelId,
-            "ACS_TASK_SENDER",
-            tm_funnel_tx.clone(),
-        ),
-        acs_thread_rx,
-        verif_reporter,
-    );
     let mut tm_funnel = TmFunnelDynamic::new(sync_tm_tcp_source, tm_funnel_rx, tm_server_tx);
 
+    let (mgm_handler_mode_reply_to_parent_tx, _mgm_handler_mode_reply_to_parent_rx) =
+        mpsc::channel();
+    let dummy_spi_interface = SpiDummyInterface::default();
+    let shared_mgm_set = Arc::default();
+    let mode_leaf_interface = MpscModeLeafInterface {
+        request_rx: mgm_handler_mode_rx,
+        reply_tx_to_pus: pus_mode_reply_tx,
+        reply_tx_to_parent: mgm_handler_mode_reply_to_parent_tx,
+    };
+    let mut mgm_handler = MgmHandlerLis3Mdl::new(
+        MGM_HANDLER_0,
+        "MGM_0",
+        mode_leaf_interface,
+        mgm_handler_composite_rx,
+        pus_hk_reply_tx,
+        tm_funnel_tx,
+        dummy_spi_interface,
+        shared_mgm_set,
+    );
+
     info!("Starting TMTC and UDP task");
     let jh_udp_tmtc = thread::Builder::new()
-        .name("TMTC and UDP".to_string())
+        .name("sat-rs tmtc-udp".to_string())
         .spawn(move || {
             info!("Running UDP server on port {SERVER_PORT}");
             loop {
@@ -440,7 +448,7 @@ fn dyn_tmtc_pool_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 {
@@ -451,7 +459,7 @@ fn dyn_tmtc_pool_main() {
 
     info!("Starting TM funnel task");
     let jh_tm_funnel = thread::Builder::new()
-        .name("TM Funnel".to_string())
+        .name("sat-rs tm-funnel".to_string())
         .spawn(move || loop {
             tm_funnel.operation();
         })
@@ -459,7 +467,7 @@ fn dyn_tmtc_pool_main() {
 
     info!("Starting event handling task");
     let jh_event_handling = thread::Builder::new()
-        .name("Event".to_string())
+        .name("sat-rs events".to_string())
         .spawn(move || loop {
             event_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_EVENT_HANDLING));
@@ -468,16 +476,16 @@ fn dyn_tmtc_pool_main() {
 
     info!("Starting AOCS thread");
     let jh_aocs = thread::Builder::new()
-        .name("AOCS".to_string())
+        .name("sat-rs aocs".to_string())
         .spawn(move || loop {
-            acs_task.periodic_operation();
+            mgm_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();
 
     info!("Starting PUS handler thread");
     let jh_pus_handler = thread::Builder::new()
-        .name("PUS".to_string())
+        .name("sat-rs pus".to_string())
         .spawn(move || loop {
             pus_stack.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_PUS_STACK));
@@ -511,7 +519,7 @@ fn main() {
     dyn_tmtc_pool_main();
 }
 
-pub fn update_time(time_provider: &mut TimeProvider, timestamp: &mut [u8]) {
+pub fn update_time(time_provider: &mut CdsTime, timestamp: &mut [u8]) {
     time_provider
         .update_from_now()
         .expect("Could not get current time");

satrs-example/src/pus/action.rs

@@ -1,155 +1,274 @@
 use log::{error, warn};
-use satrs::action::ActionRequest;
-use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
-use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
+use satrs::action::{ActionRequest, ActionRequestVariant};
+use satrs::params::WritableToBeBytes;
+use satrs::pool::SharedStaticMemoryPool;
+use satrs::pus::action::{
+    ActionReplyPus, ActionReplyVariant, ActivePusActionRequestStd, DefaultActiveActionRequestMap,
+};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, FailParamsWithStep, TcStateAccepted, TcStateStarted, VerificationReporter,
+    VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
+    EcssTcInVecConverter, EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver,
+    MpscTmAsVecSender, PusPacketHandlerResult, PusReplyHandler, PusServiceHelper,
+    PusTcToRequestConverter,
 };
-use satrs::request::TargetAndApidId;
+use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::PusPacket;
-use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::{ChannelId, TargetId};
-use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
-use std::sync::mpsc::{self};
+use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket};
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs_example::config::components::PUS_ACTION_SERVICE;
+use satrs_example::config::tmtc_err;
+use std::sync::mpsc;
+use std::time::Duration;
 
 use crate::requests::GenericRequestRouter;
 
-use super::GenericRoutingErrorHandler;
+use super::{
+    create_verification_reporter, generic_pus_request_timeout_handler, HandlingStatus,
+    PusTargetedRequestService, TargetedPusService,
+};
+
+pub struct ActionReplyHandler {
+    fail_data_buf: [u8; 128],
+}
+
+impl Default for ActionReplyHandler {
+    fn default() -> Self {
+        Self {
+            fail_data_buf: [0; 128],
+        }
+    }
+}
+
+impl PusReplyHandler<ActivePusActionRequestStd, ActionReplyPus> for ActionReplyHandler {
+    type Error = EcssTmtcError;
+
+    fn handle_unrequested_reply(
+        &mut self,
+        reply: &GenericMessage<ActionReplyPus>,
+        _tm_sender: &impl EcssTmSender,
+    ) -> Result<(), Self::Error> {
+        warn!("received unexpected reply for service 8: {reply:?}");
+        Ok(())
+    }
+
+    fn handle_reply(
+        &mut self,
+        reply: &GenericMessage<ActionReplyPus>,
+        active_request: &ActivePusActionRequestStd,
+        tm_sender: &(impl EcssTmSender + ?Sized),
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<bool, Self::Error> {
+        let verif_token: VerificationToken<TcStateStarted> = active_request
+            .token()
+            .try_into()
+            .expect("invalid token state");
+        let remove_entry = match &reply.message.variant {
+            ActionReplyVariant::CompletionFailed { error_code, params } => {
+                let mut fail_data_len = 0;
+                if let Some(params) = params {
+                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
+                }
+                verification_handler.completion_failure(
+                    tm_sender,
+                    verif_token,
+                    FailParams::new(time_stamp, error_code, &self.fail_data_buf[..fail_data_len]),
+                )?;
+                true
+            }
+            ActionReplyVariant::StepFailed {
+                error_code,
+                step,
+                params,
+            } => {
+                let mut fail_data_len = 0;
+                if let Some(params) = params {
+                    fail_data_len = params.write_to_be_bytes(&mut self.fail_data_buf)?;
+                }
+                verification_handler.step_failure(
+                    tm_sender,
+                    verif_token,
+                    FailParamsWithStep::new(
+                        time_stamp,
+                        &EcssEnumU16::new(*step),
+                        error_code,
+                        &self.fail_data_buf[..fail_data_len],
+                    ),
+                )?;
+                true
+            }
+            ActionReplyVariant::Completed => {
+                verification_handler.completion_success(tm_sender, verif_token, time_stamp)?;
+                true
+            }
+            ActionReplyVariant::StepSuccess { step } => {
+                verification_handler.step_success(
+                    tm_sender,
+                    &verif_token,
+                    time_stamp,
+                    EcssEnumU16::new(*step),
+                )?;
+                false
+            }
+            _ => false,
+        };
+        Ok(remove_entry)
+    }
+
+    fn handle_request_timeout(
+        &mut self,
+        active_request: &ActivePusActionRequestStd,
+        tm_sender: &impl EcssTmSender,
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<(), Self::Error> {
+        generic_pus_request_timeout_handler(
+            tm_sender,
+            active_request,
+            verification_handler,
+            time_stamp,
+            "action",
+        )
+    }
+}
 
 #[derive(Default)]
-pub struct ExampleActionRequestConverter {}
+pub struct ActionRequestConverter {}
 
-impl PusActionToRequestConverter for ExampleActionRequestConverter {
-    type Error = PusPacketHandlingError;
+impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for ActionRequestConverter {
+    type Error = GenericConversionError;
 
     fn convert(
         &mut self,
         token: VerificationToken<TcStateAccepted>,
         tc: &PusTcReader,
-        time_stamp: &[u8],
+        tm_sender: &(impl EcssTmSender + ?Sized),
         verif_reporter: &impl VerificationReportingProvider,
-    ) -> Result<(TargetId, ActionRequest), Self::Error> {
+        time_stamp: &[u8],
+    ) -> Result<(ActivePusActionRequestStd, ActionRequest), Self::Error> {
         let subservice = tc.subservice();
         let user_data = tc.user_data();
         if user_data.len() < 8 {
             verif_reporter
                 .start_failure(
+                    tm_sender,
                     token,
                     FailParams::new_no_fail_data(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA),
                 )
                 .expect("Sending start failure failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData {
+            return Err(GenericConversionError::NotEnoughAppData {
                 expected: 8,
                 found: user_data.len(),
             });
         }
-        let target_id = TargetAndApidId::from_pus_tc(tc).unwrap();
+        let target_id_and_apid = UniqueApidTargetId::from_pus_tc(tc).unwrap();
         let action_id = u32::from_be_bytes(user_data[4..8].try_into().unwrap());
         if subservice == 128 {
+            let req_variant = if user_data.len() == 8 {
+                ActionRequestVariant::NoData
+            } else {
+                ActionRequestVariant::VecData(user_data[8..].to_vec())
+            };
             Ok((
-                target_id.raw(),
-                ActionRequest::UnsignedIdAndVecData {
+                ActivePusActionRequestStd::new(
                     action_id,
-                    data: user_data[8..].to_vec(),
-                },
+                    target_id_and_apid.into(),
+                    token.into(),
+                    Duration::from_secs(30),
+                ),
+                ActionRequest::new(action_id, req_variant),
             ))
         } else {
             verif_reporter
                 .start_failure(
+                    tm_sender,
                     token,
                     FailParams::new_no_fail_data(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE),
                 )
                 .expect("Sending start failure failed");
-            Err(PusPacketHandlingError::InvalidSubservice(subservice))
+            Err(GenericConversionError::InvalidSubservice(subservice))
         }
     }
 }
 
 pub fn create_action_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInSharedStoreConverter> {
-    let action_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusAction as ChannelId,
-        "PUS_8_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    let action_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusAction as ChannelId,
-        "PUS_8_TC_RECV",
-        pus_action_rx,
-    );
-    let pus_8_handler = PusService8ActionHandler::new(
+    reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPus>>,
+) -> ActionServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
+    let action_request_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
-            Box::new(action_srv_receiver),
-            Box::new(action_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_ACTION_SERVICE.id(),
+            pus_action_rx,
+            tm_sender,
+            create_verification_reporter(PUS_ACTION_SERVICE.id(), PUS_ACTION_SERVICE.apid),
             EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048),
         ),
-        ExampleActionRequestConverter::default(),
+        ActionRequestConverter::default(),
+        // TODO: Implementation which does not use run-time allocation? Maybe something like
+        // a bounded wrapper which pre-allocates using [HashMap::with_capacity]..
+        DefaultActiveActionRequestMap::default(),
+        ActionReplyHandler::default(),
         action_router,
-        GenericRoutingErrorHandler::<8>::default(),
+        reply_receiver,
     );
-    Pus8Wrapper { pus_8_handler }
+    ActionServiceWrapper {
+        service: action_request_handler,
+    }
 }
 
 pub fn create_action_service_dynamic(
-    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInVecConverter> {
-    let action_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusAction as ChannelId,
-        "PUS_8_TM_SENDER",
-        tm_funnel_tx.clone(),
-    );
-    let action_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusAction as ChannelId,
-        "PUS_8_TC_RECV",
-        pus_action_rx,
-    );
-    let pus_8_handler = PusService8ActionHandler::new(
+    reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPus>>,
+) -> ActionServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
+    let action_request_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
-            Box::new(action_srv_receiver),
-            Box::new(action_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_ACTION_SERVICE.id(),
+            pus_action_rx,
+            tm_funnel_tx,
+            create_verification_reporter(PUS_ACTION_SERVICE.id(), PUS_ACTION_SERVICE.apid),
             EcssTcInVecConverter::default(),
         ),
-        ExampleActionRequestConverter::default(),
+        ActionRequestConverter::default(),
+        DefaultActiveActionRequestMap::default(),
+        ActionReplyHandler::default(),
         action_router,
-        GenericRoutingErrorHandler::<8>::default(),
+        reply_receiver,
     );
-    Pus8Wrapper { pus_8_handler }
+    ActionServiceWrapper {
+        service: action_request_handler,
+    }
 }
 
-pub struct Pus8Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub(crate) pus_8_handler: PusService8ActionHandler<
+pub struct ActionServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
+    pub(crate) service: PusTargetedRequestService<
+        MpscTcReceiver,
+        TmSender,
         TcInMemConverter,
-        VerificationReporterWithSender,
-        ExampleActionRequestConverter,
-        GenericRequestRouter,
-        GenericRoutingErrorHandler<8>,
+        VerificationReporter,
+        ActionRequestConverter,
+        ActionReplyHandler,
+        DefaultActiveActionRequestMap,
+        ActivePusActionRequestStd,
+        ActionRequest,
+        ActionReplyPus,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {
-    pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_8_handler.handle_one_tc() {
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
+    for ActionServiceWrapper<TmSender, TcInMemConverter>
+{
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
@@ -161,14 +280,476 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {
                 PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
                     warn!("PUS 8 subservice {subservice} not implemented");
                 }
-                PusPacketHandlerResult::Empty => {
-                    return true;
-                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
             },
             Err(error) => {
-                error!("PUS packet handling error: {error:?}")
+                error!("PUS packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
             }
         }
-        false
+        HandlingStatus::HandledOne
+    }
+
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        // This only fails if all senders disconnected. Treat it like an empty queue.
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS 8: Handling reply failed with error {e:?}");
+                HandlingStatus::Empty
+            })
+    }
+
+    fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    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;
+    use satrs::pus::verification::test_util::TestVerificationReporter;
+    use satrs::request::MessageMetadata;
+    use satrs::ComponentId;
+    use satrs::{
+        res_code::ResultU16,
+        spacepackets::{
+            ecss::{
+                tc::{PusTcCreator, PusTcSecondaryHeader},
+                tm::PusTmReader,
+                WritablePusPacket,
+            },
+            SpHeader,
+        },
+    };
+
+    use crate::{
+        pus::tests::{PusConverterTestbench, ReplyHandlerTestbench, TargetedPusRequestTestbench},
+        requests::CompositeRequest,
+    };
+
+    use super::*;
+
+    impl
+        TargetedPusRequestTestbench<
+            ActionRequestConverter,
+            ActionReplyHandler,
+            DefaultActiveActionRequestMap,
+            ActivePusActionRequestStd,
+            ActionRequest,
+            ActionReplyPus,
+        >
+    {
+        pub fn new_for_action(owner_id: ComponentId, target_id: ComponentId) -> Self {
+            let _ = env_logger::builder().is_test(true).try_init();
+            let (tm_funnel_tx, tm_funnel_rx) = mpsc::channel();
+            let (pus_action_tx, pus_action_rx) = mpsc::channel();
+            let (action_reply_tx, action_reply_rx) = mpsc::channel();
+            let (action_req_tx, action_req_rx) = mpsc::channel();
+            let verif_reporter = TestVerificationReporter::new(owner_id);
+            let mut generic_req_router = GenericRequestRouter::default();
+            generic_req_router
+                .composite_router_map
+                .insert(target_id, action_req_tx);
+            Self {
+                service: PusTargetedRequestService::new(
+                    PusServiceHelper::new(
+                        owner_id,
+                        pus_action_rx,
+                        tm_funnel_tx.clone(),
+                        verif_reporter,
+                        EcssTcInVecConverter::default(),
+                    ),
+                    ActionRequestConverter::default(),
+                    DefaultActiveActionRequestMap::default(),
+                    ActionReplyHandler::default(),
+                    generic_req_router,
+                    action_reply_rx,
+                ),
+                request_id: None,
+                pus_packet_tx: pus_action_tx,
+                tm_funnel_rx,
+                reply_tx: action_reply_tx,
+                request_rx: action_req_rx,
+            }
+        }
+
+        pub fn verify_packet_started(&self) {
+            self.service
+                .service_helper
+                .common
+                .verif_reporter
+                .check_next_is_started_success(
+                    self.service.service_helper.id(),
+                    self.request_id.expect("request ID not set").into(),
+                );
+        }
+
+        pub fn verify_packet_completed(&self) {
+            self.service
+                .service_helper
+                .common
+                .verif_reporter
+                .check_next_is_completion_success(
+                    self.service.service_helper.id(),
+                    self.request_id.expect("request ID not set").into(),
+                );
+        }
+
+        pub fn verify_tm_empty(&self) {
+            let packet = self.tm_funnel_rx.try_recv();
+            if let Err(mpsc::TryRecvError::Empty) = packet {
+            } else {
+                let tm = packet.unwrap();
+                let unexpected_tm = PusTmReader::new(&tm.packet, 7).unwrap().0;
+                panic!("unexpected TM packet {unexpected_tm:?}");
+            }
+        }
+
+        pub fn verify_next_tc_is_handled_properly(&mut self, time_stamp: &[u8]) {
+            let result = self.service.poll_and_handle_next_tc(time_stamp);
+            if let Err(e) = result {
+                panic!("unexpected error {:?}", e);
+            }
+            let result = result.unwrap();
+            match result {
+                PusPacketHandlerResult::RequestHandled => (),
+                _ => panic!("unexpected result {result:?}"),
+            }
+        }
+
+        pub fn verify_all_tcs_handled(&mut self, time_stamp: &[u8]) {
+            let result = self.service.poll_and_handle_next_tc(time_stamp);
+            if let Err(e) = result {
+                panic!("unexpected error {:?}", e);
+            }
+            let result = result.unwrap();
+            match result {
+                PusPacketHandlerResult::Empty => (),
+                _ => panic!("unexpected result {result:?}"),
+            }
+        }
+
+        pub fn verify_next_reply_is_handled_properly(&mut self, time_stamp: &[u8]) {
+            let result = self.service.poll_and_check_next_reply(time_stamp);
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), HandlingStatus::HandledOne);
+        }
+
+        pub fn verify_all_replies_handled(&mut self, time_stamp: &[u8]) {
+            let result = self.service.poll_and_check_next_reply(time_stamp);
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), HandlingStatus::Empty);
+        }
+
+        pub fn add_tc(&mut self, tc: &PusTcCreator) {
+            self.request_id = Some(verification::RequestId::new(tc).into());
+            let token = self.service.service_helper.verif_reporter_mut().add_tc(tc);
+            let accepted_token = self
+                .service
+                .service_helper
+                .verif_reporter()
+                .acceptance_success(self.service.service_helper.tm_sender(), token, &[0; 7])
+                .expect("TC acceptance failed");
+            self.service
+                .service_helper
+                .verif_reporter()
+                .check_next_was_added(accepted_token.request_id());
+            let id = self.service.service_helper.id();
+            self.service
+                .service_helper
+                .verif_reporter()
+                .check_next_is_acceptance_success(id, accepted_token.request_id());
+            self.pus_packet_tx
+                .send(EcssTcAndToken::new(
+                    PacketAsVec::new(self.service.service_helper.id(), tc.to_vec().unwrap()),
+                    accepted_token,
+                ))
+                .unwrap();
+        }
+    }
+
+    #[test]
+    fn basic_request() {
+        let mut testbench = TargetedPusRequestTestbench::new_for_action(
+            TEST_COMPONENT_ID_0.id(),
+            TEST_COMPONENT_ID_1.id(),
+        );
+        // Create a basic action request and verify forwarding.
+        let sp_header = SpHeader::new_from_apid(TEST_APID);
+        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.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, true);
+        testbench.add_tc(&pus8_packet);
+        let time_stamp: [u8; 7] = [0; 7];
+        testbench.verify_next_tc_is_handled_properly(&time_stamp);
+        testbench.verify_all_tcs_handled(&time_stamp);
+
+        testbench.verify_packet_started();
+
+        let possible_req = testbench.request_rx.try_recv();
+        assert!(possible_req.is_ok());
+        let req = possible_req.unwrap();
+        if let CompositeRequest::Action(action_req) = req.message {
+            assert_eq!(action_req.action_id, action_id);
+            assert_eq!(action_req.variant, ActionRequestVariant::NoData);
+            let action_reply = ActionReplyPus::new(action_id, ActionReplyVariant::Completed);
+            testbench
+                .reply_tx
+                .send(GenericMessage::new(req.requestor_info, action_reply))
+                .unwrap();
+        } else {
+            panic!("unexpected request type");
+        }
+        testbench.verify_next_reply_is_handled_properly(&time_stamp);
+        testbench.verify_all_replies_handled(&time_stamp);
+
+        testbench.verify_packet_completed();
+        testbench.verify_tm_empty();
+    }
+
+    #[test]
+    fn basic_request_routing_error() {
+        let mut testbench = TargetedPusRequestTestbench::new_for_action(
+            TEST_COMPONENT_ID_0.id(),
+            TEST_COMPONENT_ID_1.id(),
+        );
+        // Create a basic action request and verify forwarding.
+        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(&0_u32.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,
+            true,
+        );
+        testbench.add_tc(&pus8_packet);
+        let time_stamp: [u8; 7] = [0; 7];
+
+        let result = testbench.service.poll_and_handle_next_tc(&time_stamp);
+        assert!(result.is_err());
+        // Verify the correct result and completion failure.
+    }
+
+    #[test]
+    fn converter_action_req_no_data() {
+        let mut testbench = PusConverterTestbench::new(
+            TEST_COMPONENT_ID_0.raw(),
+            ActionRequestConverter::default(),
+        );
+        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.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,
+            true,
+        );
+        let token = testbench.add_tc(&pus8_packet);
+        let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
+        assert!(result.is_ok());
+        let (active_req, request) = result.unwrap();
+        if let ActionRequestVariant::NoData = request.variant {
+            assert_eq!(request.action_id, action_id);
+            assert_eq!(active_req.action_id, action_id);
+            assert_eq!(
+                active_req.target_id(),
+                UniqueApidTargetId::new(TEST_APID, TEST_UNIQUE_ID_0).raw()
+            );
+            assert_eq!(
+                active_req.token().request_id(),
+                testbench.request_id().unwrap()
+            );
+        } else {
+            panic!("unexpected action request variant");
+        }
+    }
+
+    #[test]
+    fn converter_action_req_with_data() {
+        let mut testbench =
+            PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ActionRequestConverter::default());
+        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.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;
+        }
+        let pus8_packet = PusTcCreator::new(
+            SpHeader::new_from_apid(TEST_APID),
+            sec_header,
+            &app_data,
+            true,
+        );
+        let token = testbench.add_tc(&pus8_packet);
+        let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
+        assert!(result.is_ok());
+        let (active_req, request) = result.unwrap();
+        if let ActionRequestVariant::VecData(vec) = request.variant {
+            assert_eq!(request.action_id, action_id);
+            assert_eq!(active_req.action_id, action_id);
+            assert_eq!(vec, app_data[8..].to_vec());
+        } else {
+            panic!("unexpected action request variant");
+        }
+    }
+
+    #[test]
+    fn reply_handling_completion_success() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
+        let action_id = 5_u32;
+        let (req_id, active_req) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let active_action_req =
+            ActivePusActionRequestStd::new_from_common_req(action_id, active_req);
+        let reply = ActionReplyPus::new(action_id, ActionReplyVariant::Completed);
+        let generic_reply = GenericMessage::new(MessageMetadata::new(req_id.into(), 0), reply);
+        let result = testbench.handle_reply(&generic_reply, &active_action_req, &[]);
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+        testbench.verif_reporter.assert_full_completion_success(
+            TEST_COMPONENT_ID_0.id(),
+            req_id,
+            None,
+        );
+    }
+
+    #[test]
+    fn reply_handling_completion_failure() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
+        let action_id = 5_u32;
+        let (req_id, active_req) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let active_action_req =
+            ActivePusActionRequestStd::new_from_common_req(action_id, active_req);
+        let error_code = ResultU16::new(2, 3);
+        let reply = ActionReplyPus::new(
+            action_id,
+            ActionReplyVariant::CompletionFailed {
+                error_code,
+                params: None,
+            },
+        );
+        let generic_reply = GenericMessage::new(MessageMetadata::new(req_id.into(), 0), reply);
+        let result = testbench.handle_reply(&generic_reply, &active_action_req, &[]);
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+        testbench.verif_reporter.assert_completion_failure(
+            TEST_COMPONENT_ID_0.into(),
+            req_id,
+            None,
+            error_code.raw() as u64,
+        );
+    }
+
+    #[test]
+    fn reply_handling_step_success() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
+        let action_id = 5_u32;
+        let (req_id, active_req) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let active_action_req =
+            ActivePusActionRequestStd::new_from_common_req(action_id, active_req);
+        let reply = ActionReplyPus::new(action_id, ActionReplyVariant::StepSuccess { step: 1 });
+        let generic_reply = GenericMessage::new(MessageMetadata::new(req_id.into(), 0), reply);
+        let result = testbench.handle_reply(&generic_reply, &active_action_req, &[]);
+        assert!(result.is_ok());
+        // Entry should not be removed, completion not done yet.
+        assert!(!result.unwrap());
+        testbench.verif_reporter.check_next_was_added(req_id);
+        testbench
+            .verif_reporter
+            .check_next_is_acceptance_success(TEST_COMPONENT_ID_0.raw(), req_id);
+        testbench
+            .verif_reporter
+            .check_next_is_started_success(TEST_COMPONENT_ID_0.raw(), req_id);
+        testbench
+            .verif_reporter
+            .check_next_is_step_success(TEST_COMPONENT_ID_0.raw(), req_id, 1);
+    }
+
+    #[test]
+    fn reply_handling_step_failure() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
+        let action_id = 5_u32;
+        let (req_id, active_req) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let active_action_req =
+            ActivePusActionRequestStd::new_from_common_req(action_id, active_req);
+        let error_code = ResultU16::new(2, 3);
+        let reply = ActionReplyPus::new(
+            action_id,
+            ActionReplyVariant::StepFailed {
+                error_code,
+                step: 1,
+                params: None,
+            },
+        );
+        let generic_reply = GenericMessage::new(MessageMetadata::new(req_id.into(), 0), reply);
+        let result = testbench.handle_reply(&generic_reply, &active_action_req, &[]);
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+        testbench.verif_reporter.check_next_was_added(req_id);
+        testbench
+            .verif_reporter
+            .check_next_is_acceptance_success(TEST_COMPONENT_ID_0.id(), req_id);
+        testbench
+            .verif_reporter
+            .check_next_is_started_success(TEST_COMPONENT_ID_0.id(), req_id);
+        testbench.verif_reporter.check_next_is_step_failure(
+            TEST_COMPONENT_ID_0.id(),
+            req_id,
+            error_code.raw().into(),
+        );
+    }
+
+    #[test]
+    fn reply_handling_unrequested_reply() {
+        let mut testbench =
+            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_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);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn reply_handling_reply_timeout() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
+        let action_id = 5_u32;
+        let (req_id, active_request) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let result = testbench.handle_request_timeout(
+            &ActivePusActionRequestStd::new_from_common_req(action_id, active_request),
+            &[],
+        );
+        assert!(result.is_ok());
+        testbench.verif_reporter.assert_completion_failure(
+            TEST_COMPONENT_ID_0.raw(),
+            req_id,
+            None,
+            tmtc_err::REQUEST_TIMEOUT.raw() as u64,
+        );
     }
 }

satrs-example/src/pus/event.rs

@@ -1,87 +1,71 @@
 use std::sync::mpsc;
 
+use crate::pus::create_verification_reporter;
 use log::{error, warn};
-use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
+use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::event_man::EventRequestWithToken;
-use satrs::pus::event_srv::PusService5EventHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::event_srv::PusEventServiceHandler;
+use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
-use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
+
+use super::HandlingStatus;
 
 pub fn create_event_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInSharedStoreConverter> {
-    let event_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusEvent as ChannelId,
-        "PUS_5_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    let event_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusEvent as ChannelId,
-        "PUS_5_TC_RECV",
-        pus_event_rx,
-    );
-    let pus_5_handler = PusService5EventHandler::new(
+) -> EventServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
+    let pus_5_handler = PusEventServiceHandler::new(
         PusServiceHelper::new(
-            Box::new(event_srv_receiver),
-            Box::new(event_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_EVENT_MANAGEMENT.id(),
+            pus_event_rx,
+            tm_sender,
+            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
             EcssTcInSharedStoreConverter::new(tc_pool.clone(), 2048),
         ),
         event_request_tx,
     );
-    Pus5Wrapper { pus_5_handler }
+    EventServiceWrapper {
+        handler: pus_5_handler,
+    }
 }
 
 pub fn create_event_service_dynamic(
-    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInVecConverter> {
-    let event_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusEvent as ChannelId,
-        "PUS_5_TM_SENDER",
-        tm_funnel_tx,
-    );
-    let event_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusEvent as ChannelId,
-        "PUS_5_TC_RECV",
-        pus_event_rx,
-    );
-    let pus_5_handler = PusService5EventHandler::new(
+) -> EventServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
+    let pus_5_handler = PusEventServiceHandler::new(
         PusServiceHelper::new(
-            Box::new(event_srv_receiver),
-            Box::new(event_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_EVENT_MANAGEMENT.id(),
+            pus_event_rx,
+            tm_funnel_tx,
+            create_verification_reporter(PUS_EVENT_MANAGEMENT.id(), PUS_EVENT_MANAGEMENT.apid),
             EcssTcInVecConverter::default(),
         ),
         event_request_tx,
     );
-    Pus5Wrapper { pus_5_handler }
+    EventServiceWrapper {
+        handler: pus_5_handler,
+    }
 }
 
-pub struct Pus5Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporterWithSender>,
+pub struct EventServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
+    pub handler:
+        PusEventServiceHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {
-    pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_5_handler.handle_one_tc() {
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    EventServiceWrapper<TmSender, TcInMemConverter>
+{
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.handler.poll_and_handle_next_tc(time_stamp) {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
@@ -93,14 +77,12 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {
                 PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
                     warn!("PUS 5 subservice {subservice} not implemented");
                 }
-                PusPacketHandlerResult::Empty => {
-                    return true;
-                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
             },
             Err(error) => {
                 error!("PUS packet handling error: {error:?}")
             }
         }
-        false
+        HandlingStatus::HandledOne
     }
 }

satrs-example/src/pus/hk.rs

@@ -1,47 +1,127 @@
+use derive_new::new;
 use log::{error, warn};
-use satrs::hk::{CollectionIntervalFactor, HkRequest};
-use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
-use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
+use satrs::hk::{CollectionIntervalFactor, HkRequest, HkRequestVariant, UniqueId};
+use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
+    VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
+    EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter, EcssTmSender,
+    EcssTmtcError, GenericConversionError, MpscTcReceiver, MpscTmAsVecSender,
+    PusPacketHandlerResult, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
 };
-use satrs::request::TargetAndApidId;
+use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket};
-use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::{ChannelId, TargetId};
-use satrs_example::config::{hk_err, tmtc_err, TcReceiverId, TmSenderId, PUS_APID};
-use std::sync::mpsc::{self};
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs_example::config::components::PUS_HK_SERVICE;
+use satrs_example::config::{hk_err, tmtc_err};
+use std::sync::mpsc;
+use std::time::Duration;
 
+use crate::pus::{create_verification_reporter, generic_pus_request_timeout_handler};
 use crate::requests::GenericRequestRouter;
 
-use super::GenericRoutingErrorHandler;
+use super::{HandlingStatus, PusTargetedRequestService};
+
+#[derive(Clone, PartialEq, Debug, new)]
+pub struct HkReply {
+    pub unique_id: UniqueId,
+    pub variant: HkReplyVariant,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum HkReplyVariant {
+    Ack,
+}
 
 #[derive(Default)]
-pub struct ExampleHkRequestConverter {}
+pub struct HkReplyHandler {}
 
-impl PusHkToRequestConverter for ExampleHkRequestConverter {
-    type Error = PusPacketHandlingError;
+impl PusReplyHandler<ActivePusRequestStd, HkReply> for HkReplyHandler {
+    type Error = EcssTmtcError;
+
+    fn handle_unrequested_reply(
+        &mut self,
+        reply: &GenericMessage<HkReply>,
+        _tm_sender: &impl EcssTmSender,
+    ) -> Result<(), Self::Error> {
+        log::warn!("received unexpected reply for service 3: {reply:?}");
+        Ok(())
+    }
+
+    fn handle_reply(
+        &mut self,
+        reply: &GenericMessage<HkReply>,
+        active_request: &ActivePusRequestStd,
+        tm_sender: &impl EcssTmSender,
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<bool, Self::Error> {
+        let started_token: VerificationToken<TcStateStarted> = active_request
+            .token()
+            .try_into()
+            .expect("invalid token state");
+        match reply.message.variant {
+            HkReplyVariant::Ack => {
+                verification_handler
+                    .completion_success(tm_sender, started_token, time_stamp)
+                    .expect("sending completion success verification failed");
+            }
+        };
+        Ok(true)
+    }
+
+    fn handle_request_timeout(
+        &mut self,
+        active_request: &ActivePusRequestStd,
+        tm_sender: &impl EcssTmSender,
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<(), Self::Error> {
+        generic_pus_request_timeout_handler(
+            tm_sender,
+            active_request,
+            verification_handler,
+            time_stamp,
+            "HK",
+        )?;
+        Ok(())
+    }
+}
+
+pub struct HkRequestConverter {
+    timeout: Duration,
+}
+
+impl Default for HkRequestConverter {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(60),
+        }
+    }
+}
+
+impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConverter {
+    type Error = GenericConversionError;
 
     fn convert(
         &mut self,
         token: VerificationToken<TcStateAccepted>,
         tc: &PusTcReader,
-        time_stamp: &[u8],
+        tm_sender: &(impl EcssTmSender + ?Sized),
         verif_reporter: &impl VerificationReportingProvider,
-    ) -> Result<(TargetId, HkRequest), Self::Error> {
+        time_stamp: &[u8],
+    ) -> Result<(ActivePusRequestStd, HkRequest), Self::Error> {
         let user_data = tc.user_data();
         if user_data.is_empty() {
             let user_data_len = user_data.len() as u32;
             let user_data_len_raw = user_data_len.to_be_bytes();
             verif_reporter
                 .start_failure(
+                    tm_sender,
                     token,
                     FailParams::new(
                         time_stamp,
@@ -50,7 +130,7 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
                     ),
                 )
                 .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData {
+            return Err(GenericConversionError::NotEnoughAppData {
                 expected: 4,
                 found: 0,
             });
@@ -64,46 +144,50 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
             let user_data_len = user_data.len() as u32;
             let user_data_len_raw = user_data_len.to_be_bytes();
             verif_reporter
-                .start_failure(token, FailParams::new(time_stamp, err, &user_data_len_raw))
+                .start_failure(
+                    tm_sender,
+                    token,
+                    FailParams::new(time_stamp, err, &user_data_len_raw),
+                )
                 .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::NotEnoughAppData {
+            return Err(GenericConversionError::NotEnoughAppData {
                 expected: 8,
                 found: 4,
             });
         }
         let subservice = tc.subservice();
-        let target_id = TargetAndApidId::from_pus_tc(tc).expect("invalid tc format");
+        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::Subservice::try_from(subservice);
         if standard_subservice.is_err() {
             verif_reporter
                 .start_failure(
+                    tm_sender,
                     token,
                     FailParams::new(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE, &[subservice]),
                 )
                 .expect("Sending start failure TM failed");
-            return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+            return Err(GenericConversionError::InvalidSubservice(subservice));
         }
-        Ok((
-            target_id.into(),
-            match standard_subservice.unwrap() {
+        let request = match standard_subservice.unwrap() {
             hk::Subservice::TcEnableHkGeneration | hk::Subservice::TcEnableDiagGeneration => {
-                    HkRequest::Enable(unique_id)
+                HkRequest::new(unique_id, HkRequestVariant::EnablePeriodic)
             }
             hk::Subservice::TcDisableHkGeneration | hk::Subservice::TcDisableDiagGeneration => {
-                    HkRequest::Disable(unique_id)
+                HkRequest::new(unique_id, HkRequestVariant::DisablePeriodic)
             }
             hk::Subservice::TcReportHkReportStructures => todo!(),
             hk::Subservice::TmHkPacket => todo!(),
             hk::Subservice::TcGenerateOneShotHk | hk::Subservice::TcGenerateOneShotDiag => {
-                    HkRequest::OneShot(unique_id)
+                HkRequest::new(unique_id, HkRequestVariant::OneShot)
             }
             hk::Subservice::TcModifyDiagCollectionInterval
             | hk::Subservice::TcModifyHkCollectionInterval => {
                 if user_data.len() < 12 {
                     verif_reporter
                         .start_failure(
+                            tm_sender,
                             token,
                             FailParams::new_no_fail_data(
                                 time_stamp,
@@ -111,21 +195,24 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
                             ),
                         )
                         .expect("Sending start failure TM failed");
-                        return Err(PusPacketHandlingError::NotEnoughAppData {
+                    return Err(GenericConversionError::NotEnoughAppData {
                         expected: 12,
                         found: user_data.len(),
                     });
                 }
-                    HkRequest::ModifyCollectionInterval(
+                HkRequest::new(
                     unique_id,
+                    HkRequestVariant::ModifyCollectionInterval(
                         CollectionIntervalFactor::from_be_bytes(
                             user_data[8..12].try_into().unwrap(),
                         ),
+                    ),
                 )
             }
             _ => {
                 verif_reporter
                     .start_failure(
+                        tm_sender,
                         token,
                         FailParams::new(
                             time_stamp,
@@ -134,85 +221,87 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
                         ),
                     )
                     .expect("Sending start failure TM failed");
-                    return Err(PusPacketHandlingError::InvalidSubservice(subservice));
+                return Err(GenericConversionError::InvalidSubservice(subservice));
             }
-            },
+        };
+        Ok((
+            ActivePusRequestStd::new(target_id_and_apid.into(), token, self.timeout),
+            request,
         ))
     }
 }
 
 pub fn create_hk_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
-    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusHk as ChannelId,
-        "PUS_3_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    let hk_srv_receiver =
-        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
-    let pus_3_handler = PusService3HkHandler::new(
+    reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
+) -> HkServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
+    let pus_3_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
-            Box::new(hk_srv_receiver),
-            Box::new(hk_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_HK_SERVICE.id(),
+            pus_hk_rx,
+            tm_sender,
+            create_verification_reporter(PUS_HK_SERVICE.id(), PUS_HK_SERVICE.apid),
             EcssTcInSharedStoreConverter::new(tc_pool, 2048),
         ),
-        ExampleHkRequestConverter::default(),
+        HkRequestConverter::default(),
+        DefaultActiveRequestMap::default(),
+        HkReplyHandler::default(),
         request_router,
-        GenericRoutingErrorHandler::default(),
+        reply_receiver,
     );
-    Pus3Wrapper { pus_3_handler }
+    HkServiceWrapper {
+        service: pus_3_handler,
+    }
 }
 
 pub fn create_hk_service_dynamic(
-    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInVecConverter> {
-    let hk_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusHk as ChannelId,
-        "PUS_3_TM_SENDER",
-        tm_funnel_tx.clone(),
-    );
-    let hk_srv_receiver =
-        MpscTcReceiver::new(TcReceiverId::PusHk as ChannelId, "PUS_8_TC_RECV", pus_hk_rx);
-    let pus_3_handler = PusService3HkHandler::new(
+    reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
+) -> HkServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
+    let pus_3_handler = PusTargetedRequestService::new(
         PusServiceHelper::new(
-            Box::new(hk_srv_receiver),
-            Box::new(hk_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_HK_SERVICE.id(),
+            pus_hk_rx,
+            tm_funnel_tx,
+            create_verification_reporter(PUS_HK_SERVICE.id(), PUS_HK_SERVICE.apid),
             EcssTcInVecConverter::default(),
         ),
-        ExampleHkRequestConverter::default(),
+        HkRequestConverter::default(),
+        DefaultActiveRequestMap::default(),
+        HkReplyHandler::default(),
         request_router,
-        GenericRoutingErrorHandler::default(),
+        reply_receiver,
     );
-    Pus3Wrapper { pus_3_handler }
+    HkServiceWrapper {
+        service: pus_3_handler,
+    }
 }
 
-pub struct Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub(crate) pus_3_handler: PusService3HkHandler<
+pub struct HkServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
+    pub(crate) service: PusTargetedRequestService<
+        MpscTcReceiver,
+        TmSender,
         TcInMemConverter,
-        VerificationReporterWithSender,
-        ExampleHkRequestConverter,
-        GenericRequestRouter,
-        GenericRoutingErrorHandler<3>,
+        VerificationReporter,
+        HkRequestConverter,
+        HkReplyHandler,
+        DefaultActiveRequestMap<ActivePusRequestStd>,
+        ActivePusRequestStd,
+        HkRequest,
+        HkReply,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {
-    pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_3_handler.handle_one_tc() {
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    HkServiceWrapper<TmSender, TcInMemConverter>
+{
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
@@ -224,14 +313,252 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {
                 PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
                     warn!("PUS 3 subservice {subservice} not implemented");
                 }
-                PusPacketHandlerResult::Empty => {
-                    return true;
-                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
             },
             Err(error) => {
-                error!("PUS packet handling error: {error:?}")
+                error!("PUS packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
             }
         }
-        false
+        HandlingStatus::HandledOne
+    }
+
+    pub fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        // This only fails if all senders disconnected. Treat it like an empty queue.
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS 3: Handling reply failed with error {e:?}");
+                HandlingStatus::Empty
+            })
+    }
+
+    pub fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    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::{
+        hk::HkRequestVariant,
+        pus::test_util::TEST_APID,
+        request::GenericMessage,
+        spacepackets::{
+            ecss::{hk::Subservice, tc::PusTcCreator},
+            SpHeader,
+        },
+    };
+    use satrs_example::config::tmtc_err;
+
+    use crate::pus::{
+        hk::HkReplyVariant,
+        tests::{PusConverterTestbench, ReplyHandlerTestbench},
+    };
+
+    use super::{HkReply, HkReplyHandler, HkRequestConverter};
+
+    #[test]
+    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, 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.to_be_bytes());
+        app_data[4..8].copy_from_slice(&unique_id.to_be_bytes());
+
+        let hk_req = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcGenerateOneShotHk as u8,
+            &app_data,
+            true,
+        );
+        let accepted_token = hk_bench.add_tc(&hk_req);
+        let (_active_req, req) = hk_bench
+            .convert(accepted_token, &[], TEST_APID, TEST_UNIQUE_ID_0)
+            .expect("conversion failed");
+
+        assert_eq!(req.unique_id, unique_id);
+        if let HkRequestVariant::OneShot = req.variant {
+        } else {
+            panic!("unexpected HK request")
+        }
+    }
+
+    #[test]
+    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, 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.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);
+            let (_active_req, req) = hk_bench
+                .convert(accepted_token, &[], TEST_APID, TEST_UNIQUE_ID_0)
+                .expect("conversion failed");
+            assert_eq!(req.unique_id, unique_id);
+            if let HkRequestVariant::EnablePeriodic = req.variant {
+            } else {
+                panic!("unexpected HK request")
+            }
+        };
+        let tc0 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcEnableHkGeneration as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc0);
+        let tc1 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcEnableDiagGeneration as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc1);
+    }
+
+    #[test]
+    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, 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.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);
+            let (_active_req, req) = hk_bench
+                .convert(accepted_token, &[], TEST_APID, TEST_UNIQUE_ID_0)
+                .expect("conversion failed");
+            assert_eq!(req.unique_id, unique_id);
+            if let HkRequestVariant::DisablePeriodic = req.variant {
+            } else {
+                panic!("unexpected HK request")
+            }
+        };
+        let tc0 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcDisableHkGeneration as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc0);
+        let tc1 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcDisableDiagGeneration as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc1);
+    }
+
+    #[test]
+    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, 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.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());
+
+        let mut generic_check = |tc: &PusTcCreator| {
+            let accepted_token = hk_bench.add_tc(tc);
+            let (_active_req, req) = hk_bench
+                .convert(accepted_token, &[], TEST_APID, TEST_UNIQUE_ID_0)
+                .expect("conversion failed");
+            assert_eq!(req.unique_id, unique_id);
+            if let HkRequestVariant::ModifyCollectionInterval(interval_factor) = req.variant {
+                assert_eq!(interval_factor, collection_interval_factor);
+            } else {
+                panic!("unexpected HK request")
+            }
+        };
+        let tc0 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcModifyHkCollectionInterval as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc0);
+        let tc1 = PusTcCreator::new_simple(
+            sp_header,
+            3,
+            Subservice::TcModifyDiagCollectionInterval as u8,
+            &app_data,
+            true,
+        );
+        generic_check(&tc1);
+    }
+
+    #[test]
+    fn hk_reply_handler() {
+        let mut reply_testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), HkReplyHandler::default());
+        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(
+            MessageMetadata::new(req_id.into(), sender_id),
+            HkReply::new(unique_id, HkReplyVariant::Ack),
+        );
+        let result = reply_testbench.handle_reply(&reply, &active_req, &[]);
+        assert!(result.is_ok());
+        assert!(result.unwrap());
+        reply_testbench
+            .verif_reporter
+            .assert_full_completion_success(TEST_COMPONENT_ID_0.raw(), req_id, None);
+    }
+
+    #[test]
+    fn reply_handling_unrequested_reply() {
+        let mut testbench =
+            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_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);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn reply_handling_reply_timeout() {
+        let mut testbench =
+            ReplyHandlerTestbench::new(TEST_COMPONENT_ID_1.id(), HkReplyHandler::default());
+        let (req_id, active_request) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_1, &[]);
+        let result = testbench.handle_request_timeout(&active_request, &[]);
+        assert!(result.is_ok());
+        testbench.verif_reporter.assert_completion_failure(
+            TEST_COMPONENT_ID_1.raw(),
+            req_id,
+            None,
+            tmtc_err::REQUEST_TIMEOUT.raw() as u64,
+        );
     }
 }

satrs-example/src/pus/mod.rs

@@ -1,122 +1,154 @@
-use crate::tmtc::MpscStoreAndSendError;
+use crate::requests::GenericRequestRouter;
 use log::warn;
+use satrs::pool::PoolAddr;
 use satrs::pus::verification::{
-    FailParams, StdVerifReporterWithSender, VerificationReportingProvider,
+    self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
+    VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    EcssTcAndToken, GenericRoutingError, PusPacketHandlerResult, PusRoutingErrorHandler, TcInMemory,
+    ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter,
+    EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError, GenericRoutingError,
+    PusPacketHandlerResult, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
+    PusServiceHelper, PusTcToRequestConverter, TcInMemory,
 };
+use satrs::queue::{GenericReceiveError, GenericSendError};
+use satrs::request::{Apid, GenericMessage, MessageMetadata};
 use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::PusServiceId;
-use satrs::spacepackets::time::cds::TimeProvider;
-use satrs::spacepackets::time::TimeWriter;
+use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
+use satrs::tmtc::{PacketAsVec, PacketInPool};
+use satrs::ComponentId;
+use satrs_example::config::components::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
-use std::sync::mpsc::Sender;
+use satrs_example::TimeStampHelper;
+use std::fmt::Debug;
+use std::sync::mpsc::{self, Sender};
 
 pub mod action;
 pub mod event;
 pub mod hk;
+pub mod mode;
 pub mod scheduler;
 pub mod stack;
 pub mod test;
 
-pub struct PusTcMpscRouter {
-    pub test_service_receiver: Sender<EcssTcAndToken>,
-    pub event_service_receiver: Sender<EcssTcAndToken>,
-    pub sched_service_receiver: Sender<EcssTcAndToken>,
-    pub hk_service_receiver: Sender<EcssTcAndToken>,
-    pub action_service_receiver: Sender<EcssTcAndToken>,
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum HandlingStatus {
+    Empty,
+    HandledOne,
 }
 
-pub struct PusReceiver {
-    pub verif_reporter: StdVerifReporterWithSender,
+pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
+    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: Sender<EcssTcAndToken>,
+    pub event_tc_sender: Sender<EcssTcAndToken>,
+    pub sched_tc_sender: Sender<EcssTcAndToken>,
+    pub hk_tc_sender: Sender<EcssTcAndToken>,
+    pub action_tc_sender: Sender<EcssTcAndToken>,
+    pub mode_tc_sender: Sender<EcssTcAndToken>,
+}
+
+pub struct PusTcDistributor<TmSender: EcssTmSender> {
+    pub id: ComponentId,
+    pub tm_sender: TmSender,
+    pub verif_reporter: VerificationReporter,
     pub pus_router: PusTcMpscRouter,
     stamp_helper: TimeStampHelper,
 }
 
-struct TimeStampHelper {
-    stamper: TimeProvider,
-    time_stamp: [u8; 7],
-}
-
-impl TimeStampHelper {
-    pub fn new() -> Self {
+impl<TmSender: EcssTmSender> PusTcDistributor<TmSender> {
+    pub fn new(tm_sender: TmSender, pus_router: PusTcMpscRouter) -> Self {
         Self {
-            stamper: TimeProvider::new_with_u16_days(0, 0),
-            time_stamp: [0; 7],
-        }
-    }
-
-    pub fn stamp(&self) -> &[u8] {
-        &self.time_stamp
-    }
-
-    pub fn update_from_now(&mut self) {
-        self.stamper
-            .update_from_now()
-            .expect("Updating timestamp failed");
-        self.stamper
-            .write_to_bytes(&mut self.time_stamp)
-            .expect("Writing timestamp failed");
-    }
-}
-
-impl PusReceiver {
-    pub fn new(verif_reporter: StdVerifReporterWithSender, pus_router: PusTcMpscRouter) -> Self {
-        Self {
-            verif_reporter,
+            id: PUS_ROUTING_SERVICE.raw(),
+            tm_sender,
+            verif_reporter: create_verification_reporter(
+                PUS_ROUTING_SERVICE.id(),
+                PUS_ROUTING_SERVICE.apid,
+            ),
             pus_router,
-            stamp_helper: TimeStampHelper::new(),
-        }
+            stamp_helper: TimeStampHelper::default(),
         }
     }
 
-impl PusReceiver {
-    pub fn handle_tc_packet(
+    pub fn handle_tc_packet_vec(
         &mut self,
-        tc_in_memory: TcInMemory,
-        service: u8,
-        pus_tc: &PusTcReader,
-    ) -> Result<PusPacketHandlerResult, MpscStoreAndSendError> {
-        let init_token = self.verif_reporter.add_tc(pus_tc);
+        packet_as_vec: PacketAsVec,
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        self.handle_tc_generic(packet_as_vec.sender_id, None, &packet_as_vec.packet)
+    }
+
+    pub fn handle_tc_packet_in_store(
+        &mut self,
+        packet_in_pool: PacketInPool,
+        pus_tc_copy: &[u8],
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        self.handle_tc_generic(
+            packet_in_pool.sender_id,
+            Some(packet_in_pool.store_addr),
+            pus_tc_copy,
+        )
+    }
+
+    pub fn handle_tc_generic(
+        &mut self,
+        sender_id: ComponentId,
+        addr_opt: Option<PoolAddr>,
+        raw_tc: &[u8],
+    ) -> Result<PusPacketHandlerResult, GenericSendError> {
+        let pus_tc_result = PusTcReader::new(raw_tc);
+        if pus_tc_result.is_err() {
+            log::warn!(
+                "error creating PUS TC from raw data received from {}: {}",
+                sender_id,
+                pus_tc_result.unwrap_err()
+            );
+            log::warn!("raw data: {:x?}", raw_tc);
+            return Ok(PusPacketHandlerResult::RequestHandled);
+        }
+        let pus_tc = pus_tc_result.unwrap().0;
+        let init_token = self.verif_reporter.add_tc(&pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
             .verif_reporter
-            .acceptance_success(init_token, self.stamp_helper.stamp())
+            .acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
-        let service = PusServiceId::try_from(service);
+        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 {
+            PacketAsVec::new(sender_id, Vec::from(raw_tc)).into()
+        };
         match service {
             Ok(standard_service) => match standard_service {
-                PusServiceId::Test => {
-                    self.pus_router.test_service_receiver.send(EcssTcAndToken {
+                PusServiceId::Test => self.pus_router.test_tc_sender.send(EcssTcAndToken {
                     tc_in_memory,
                     token: Some(accepted_token.into()),
-                    })?
-                }
+                })?,
                 PusServiceId::Housekeeping => {
-                    self.pus_router.hk_service_receiver.send(EcssTcAndToken {
+                    self.pus_router.hk_tc_sender.send(EcssTcAndToken {
                         tc_in_memory,
                         token: Some(accepted_token.into()),
                     })?
                 }
-                PusServiceId::Event => {
-                    self.pus_router
-                        .event_service_receiver
-                        .send(EcssTcAndToken {
+                PusServiceId::Event => self.pus_router.event_tc_sender.send(EcssTcAndToken {
                     tc_in_memory,
                     token: Some(accepted_token.into()),
-                        })?
-                }
+                })?,
                 PusServiceId::Scheduling => {
-                    self.pus_router
-                        .sched_service_receiver
-                        .send(EcssTcAndToken {
+                    self.pus_router.sched_tc_sender.send(EcssTcAndToken {
                         tc_in_memory,
                         token: Some(accepted_token.into()),
                     })?
                 }
                 _ => {
                     let result = self.verif_reporter.start_failure(
+                        &self.tm_sender,
                         accepted_token,
                         FailParams::new(
                             self.stamp_helper.stamp(),
@@ -132,15 +164,20 @@ impl PusReceiver {
             Err(e) => {
                 if let Ok(custom_service) = CustomPusServiceId::try_from(e.number) {
                     match custom_service {
-                        CustomPusServiceId::Mode => {
-                            // TODO: Fix mode service.
-                            //self.handle_mode_service(pus_tc, accepted_token)
-                        }
+                        CustomPusServiceId::Mode => self
+                            .pus_router
+                            .mode_tc_sender
+                            .send(EcssTcAndToken {
+                                tc_in_memory,
+                                token: Some(accepted_token.into()),
+                            })
+                            .map_err(|_| GenericSendError::RxDisconnected)?,
                         CustomPusServiceId::Health => {}
                     }
                 } else {
                     self.verif_reporter
                         .start_failure(
+                            &self.tm_sender,
                             accepted_token,
                             FailParams::new(
                                 self.stamp_helper.stamp(),
@@ -156,55 +193,551 @@ impl PusReceiver {
     }
 }
 
-#[derive(Default)]
-pub struct GenericRoutingErrorHandler<const SERVICE_ID: u8> {}
+pub trait TargetedPusService {
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus;
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus;
+    fn check_for_request_timeouts(&mut self);
+}
 
-impl<const SERVICE_ID: u8> PusRoutingErrorHandler for GenericRoutingErrorHandler<SERVICE_ID> {
-    type Error = satrs::pus::GenericRoutingError;
+/// This is a generic handler class for all PUS services where a PUS telecommand is converted
+/// to a targeted request.
+///
+/// The generic steps for this process are the following
+///
+///  1. Poll for TC packets
+///  2. Convert the raw packets to a [PusTcReader].
+///  3. Convert the PUS TC to a typed request using the [PusTcToRequestConverter].
+///  4. Route the requests using the [GenericRequestRouter].
+///  5. Add the request to the active request map using the [ActiveRequestMapProvider] abstraction.
+///  6. Check for replies which complete the forwarded request. The handler takes care of
+///     the verification process.
+///  7. Check for timeouts of active requests. Generally, the timeout on the service level should
+///     be highest expected timeout for the given target.
+///
+/// The handler exposes the following API:
+///
+///  1. [Self::poll_and_handle_next_tc] which tries to poll and handle one TC packet, covering
+///     steps 1-5.
+///  2. [Self::poll_and_check_next_reply] which tries to poll and handle one reply, covering step 6.
+///  3. [Self::check_for_request_timeouts] which checks for request timeouts, covering step 7.
+pub struct PusTargetedRequestService<
+    TcReceiver: EcssTcReceiver,
+    TmSender: EcssTmSender,
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+    RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
+    ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
+    ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+    ActiveRequestInfo: ActiveRequestProvider,
+    RequestType,
+    ReplyType,
+> {
+    pub service_helper:
+        PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
+    pub request_router: GenericRequestRouter,
+    pub request_converter: RequestConverter,
+    pub active_request_map: ActiveRequestMap,
+    pub reply_handler: ReplyHandler,
+    pub reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
+    phantom: std::marker::PhantomData<(RequestType, ActiveRequestInfo, ReplyType)>,
+}
 
-    fn handle_error(
-        &self,
-        target_id: satrs::TargetId,
-        token: satrs::pus::verification::VerificationToken<
-            satrs::pus::verification::TcStateAccepted,
+impl<
+        TcReceiver: EcssTcReceiver,
+        TmSender: EcssTmSender,
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+        RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
+        ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
+        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequestProvider,
+        RequestType,
+        ReplyType,
+    >
+    PusTargetedRequestService<
+        TcReceiver,
+        TmSender,
+        TcInMemConverter,
+        VerificationReporter,
+        RequestConverter,
+        ReplyHandler,
+        ActiveRequestMap,
+        ActiveRequestInfo,
+        RequestType,
+        ReplyType,
+    >
+where
+    GenericRequestRouter: PusRequestRouter<RequestType, Error = GenericRoutingError>,
+{
+    pub fn new(
+        service_helper: PusServiceHelper<
+            TcReceiver,
+            TmSender,
+            TcInMemConverter,
+            VerificationReporter,
         >,
-        _tc: &PusTcReader,
-        error: Self::Error,
+        request_converter: RequestConverter,
+        active_request_map: ActiveRequestMap,
+        reply_hook: ReplyHandler,
+        request_router: GenericRequestRouter,
+        reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
+    ) -> Self {
+        Self {
+            service_helper,
+            request_converter,
+            active_request_map,
+            reply_handler: reply_hook,
+            request_router,
+            reply_receiver,
+            phantom: std::marker::PhantomData,
+        }
+    }
+
+    pub fn poll_and_handle_next_tc(
+        &mut self,
+        time_stamp: &[u8],
+    ) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
+        let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
+        if possible_packet.is_none() {
+            return Ok(PusPacketHandlerResult::Empty);
+        }
+        let ecss_tc_and_token = possible_packet.unwrap();
+        self.service_helper
+            .tc_in_mem_converter_mut()
+            .cache(&ecss_tc_and_token.tc_in_memory)?;
+        let tc = self.service_helper.tc_in_mem_converter().convert()?;
+        let (mut request_info, request) = match self.request_converter.convert(
+            ecss_tc_and_token.token,
+            &tc,
+            self.service_helper.tm_sender(),
+            &self.service_helper.common.verif_reporter,
+            time_stamp,
+        ) {
+            Ok((info, req)) => (info, req),
+            Err(e) => {
+                self.handle_conversion_to_request_error(&e, ecss_tc_and_token.token, time_stamp);
+                return Err(e.into());
+            }
+        };
+        let accepted_token: VerificationToken<TcStateAccepted> = request_info
+            .token()
+            .try_into()
+            .expect("token not in expected accepted state");
+        let verif_request_id = verification::RequestId::new(&tc).raw();
+        match self.request_router.route(
+            MessageMetadata::new(verif_request_id, self.service_helper.id()),
+            request_info.target_id(),
+            request,
+        ) {
+            Ok(()) => {
+                let started_token = self
+                    .service_helper
+                    .verif_reporter()
+                    .start_success(
+                        &self.service_helper.common.tm_sender,
+                        accepted_token,
+                        time_stamp,
+                    )
+                    .expect("Start success failure");
+                request_info.set_token(started_token.into());
+                self.active_request_map
+                    .insert(&verif_request_id, request_info);
+            }
+            Err(e) => {
+                self.request_router.handle_error_generic(
+                    &request_info,
+                    &tc,
+                    e.clone(),
+                    self.service_helper.tm_sender(),
+                    self.service_helper.verif_reporter(),
+                    time_stamp,
+                );
+                return Err(e.into());
+            }
+        }
+        Ok(PusPacketHandlerResult::RequestHandled)
+    }
+
+    fn handle_conversion_to_request_error(
+        &mut self,
+        error: &GenericConversionError,
+        token: VerificationToken<TcStateAccepted>,
         time_stamp: &[u8],
-        verif_reporter: &impl VerificationReportingProvider,
     ) {
-        warn!("Routing request for service {SERVICE_ID} failed: {error:?}");
         match error {
-            GenericRoutingError::UnknownTargetId(id) => {
-                let mut fail_data: [u8; 8] = [0; 8];
-                fail_data.copy_from_slice(&id.to_be_bytes());
-                verif_reporter
-                    .start_failure(
+            GenericConversionError::WrongService(service) => {
+                let service_slice: [u8; 1] = [*service];
+                self.service_helper
+                    .verif_reporter()
+                    .completion_failure(
+                        self.service_helper.tm_sender(),
                         token,
-                        FailParams::new(time_stamp, &tmtc_err::UNKNOWN_TARGET_ID, &fail_data),
+                        FailParams::new(time_stamp, &tmtc_err::INVALID_PUS_SERVICE, &service_slice),
                     )
-                    .expect("Sending start failure failed");
+                    .expect("Sending completion failure failed");
             }
-            GenericRoutingError::SendError(_) => {
-                let mut fail_data: [u8; 8] = [0; 8];
-                fail_data.copy_from_slice(&target_id.to_be_bytes());
-                verif_reporter
-                    .start_failure(
+            GenericConversionError::InvalidSubservice(subservice) => {
+                let subservice_slice: [u8; 1] = [*subservice];
+                self.service_helper
+                    .verif_reporter()
+                    .completion_failure(
+                        self.service_helper.tm_sender(),
                         token,
-                        FailParams::new(time_stamp, &tmtc_err::ROUTING_ERROR, &fail_data),
+                        FailParams::new(
+                            time_stamp,
+                            &tmtc_err::INVALID_PUS_SUBSERVICE,
+                            &subservice_slice,
+                        ),
                     )
-                    .expect("Sending start failure failed");
+                    .expect("Sending completion failure failed");
             }
-            GenericRoutingError::NotEnoughAppData { expected, found } => {
-                let mut context_info = (found as u32).to_be_bytes().to_vec();
-                context_info.extend_from_slice(&(expected as u32).to_be_bytes());
-                verif_reporter
-                    .start_failure(
+            GenericConversionError::NotEnoughAppData { expected, found } => {
+                let mut context_info = (*found as u32).to_be_bytes().to_vec();
+                context_info.extend_from_slice(&(*expected as u32).to_be_bytes());
+                self.service_helper
+                    .verif_reporter()
+                    .completion_failure(
+                        self.service_helper.tm_sender(),
                         token,
                         FailParams::new(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA, &context_info),
                     )
-                    .expect("Sending start failure failed");
+                    .expect("Sending completion failure failed");
+            }
+            // Do nothing.. this is service-level and can not be handled generically here.
+            GenericConversionError::InvalidAppData(_) => (),
+        }
+    }
+
+    pub fn poll_and_check_next_reply(
+        &mut self,
+        time_stamp: &[u8],
+    ) -> Result<HandlingStatus, EcssTmtcError> {
+        match self.reply_receiver.try_recv() {
+            Ok(reply) => {
+                self.handle_reply(&reply, time_stamp)?;
+                Ok(HandlingStatus::HandledOne)
+            }
+            Err(e) => match e {
+                mpsc::TryRecvError::Empty => Ok(HandlingStatus::Empty),
+                mpsc::TryRecvError::Disconnected => Err(EcssTmtcError::Receive(
+                    GenericReceiveError::TxDisconnected(None),
+                )),
+            },
+        }
+    }
+
+    pub fn handle_reply(
+        &mut self,
+        reply: &GenericMessage<ReplyType>,
+        time_stamp: &[u8],
+    ) -> Result<(), EcssTmtcError> {
+        let active_req_opt = self.active_request_map.get(reply.request_id());
+        if active_req_opt.is_none() {
+            self.reply_handler
+                .handle_unrequested_reply(reply, &self.service_helper.common.tm_sender)?;
+            return Ok(());
+        }
+        let active_request = active_req_opt.unwrap();
+        let request_finished = self
+            .reply_handler
+            .handle_reply(
+                reply,
+                active_request,
+                &self.service_helper.common.tm_sender,
+                &self.service_helper.common.verif_reporter,
+                time_stamp,
+            )
+            .unwrap_or(false);
+        if request_finished {
+            self.active_request_map.remove(reply.request_id());
+        }
+        Ok(())
+    }
+
+    pub fn check_for_request_timeouts(&mut self) {
+        let mut requests_to_delete = Vec::new();
+        self.active_request_map
+            .for_each(|request_id, request_info| {
+                if request_info.has_timed_out() {
+                    requests_to_delete.push(*request_id);
+                }
+            });
+        if !requests_to_delete.is_empty() {
+            for request_id in requests_to_delete {
+                self.active_request_map.remove(request_id);
             }
         }
     }
 }
+
+/// Generic timeout handling: Handle the verification failure with a dedicated return code
+/// and also log the error.
+pub fn generic_pus_request_timeout_handler(
+    sender: &(impl EcssTmSender + ?Sized),
+    active_request: &(impl ActiveRequestProvider + Debug),
+    verification_handler: &impl VerificationReportingProvider,
+    time_stamp: &[u8],
+    service_str: &'static str,
+) -> Result<(), EcssTmtcError> {
+    log::warn!("timeout for active request {active_request:?} on {service_str} service");
+    let started_token: VerificationToken<TcStateStarted> = active_request
+        .token()
+        .try_into()
+        .expect("token not in expected started state");
+    verification_handler.completion_failure(
+        sender,
+        started_token,
+        FailParams::new(time_stamp, &tmtc_err::REQUEST_TIMEOUT, &[]),
+    )?;
+    Ok(())
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use std::time::Duration;
+
+    use satrs::pus::test_util::TEST_COMPONENT_ID_0;
+    use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
+    use satrs::request::RequestId;
+    use satrs::{
+        pus::{
+            verification::test_util::TestVerificationReporter, ActivePusRequestStd,
+            ActiveRequestMapProvider, EcssTcInVecConverter, MpscTcReceiver,
+        },
+        request::UniqueApidTargetId,
+        spacepackets::{
+            ecss::{
+                tc::{PusTcCreator, PusTcSecondaryHeader},
+                WritablePusPacket,
+            },
+            SpHeader,
+        },
+    };
+
+    use crate::requests::CompositeRequest;
+
+    use super::*;
+
+    // Testbench dedicated to the testing of [PusReplyHandler]s
+    pub struct ReplyHandlerTestbench<
+        ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
+        ActiveRequestInfo: ActiveRequestProvider,
+        Reply,
+    > {
+        pub id: ComponentId,
+        pub verif_reporter: TestVerificationReporter,
+        pub reply_handler: ReplyHandler,
+        pub tm_receiver: mpsc::Receiver<PacketAsVec>,
+        pub default_timeout: Duration,
+        tm_sender: MpscTmAsVecSender,
+        phantom: std::marker::PhantomData<(ActiveRequestInfo, Reply)>,
+    }
+
+    impl<
+            ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
+            ActiveRequestInfo: ActiveRequestProvider,
+            Reply,
+        > ReplyHandlerTestbench<ReplyHandler, ActiveRequestInfo, Reply>
+    {
+        pub fn new(owner_id: ComponentId, reply_handler: ReplyHandler) -> Self {
+            let test_verif_reporter = TestVerificationReporter::new(owner_id);
+            let (tm_sender, tm_receiver) = mpsc::channel();
+            Self {
+                id: TEST_COMPONENT_ID_0.raw(),
+                verif_reporter: test_verif_reporter,
+                reply_handler,
+                default_timeout: Duration::from_secs(30),
+                tm_sender,
+                tm_receiver,
+                phantom: std::marker::PhantomData,
+            }
+        }
+
+        pub fn add_tc(
+            &mut self,
+            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(0, 0);
+            let init = self.verif_reporter.add_tc(&PusTcCreator::new(
+                sp_header,
+                sec_header_dummy,
+                &[],
+                true,
+            ));
+            let accepted = self
+                .verif_reporter
+                .acceptance_success(&self.tm_sender, init, time_stamp)
+                .expect("acceptance failed");
+            let started = self
+                .verif_reporter
+                .start_success(&self.tm_sender, accepted, time_stamp)
+                .expect("start failed");
+            (
+                started.request_id(),
+                ActivePusRequestStd::new(
+                    UniqueApidTargetId::new(apid, apid_target).raw(),
+                    started,
+                    self.default_timeout,
+                ),
+            )
+        }
+
+        pub fn handle_reply(
+            &mut self,
+            reply: &GenericMessage<Reply>,
+            active_request: &ActiveRequestInfo,
+            time_stamp: &[u8],
+        ) -> Result<bool, ReplyHandler::Error> {
+            self.reply_handler.handle_reply(
+                reply,
+                active_request,
+                &self.tm_sender,
+                &self.verif_reporter,
+                time_stamp,
+            )
+        }
+
+        pub fn handle_unrequested_reply(
+            &mut self,
+            reply: &GenericMessage<Reply>,
+        ) -> Result<(), ReplyHandler::Error> {
+            self.reply_handler
+                .handle_unrequested_reply(reply, &self.tm_sender)
+        }
+        pub fn handle_request_timeout(
+            &mut self,
+            active_request_info: &ActiveRequestInfo,
+            time_stamp: &[u8],
+        ) -> Result<(), ReplyHandler::Error> {
+            self.reply_handler.handle_request_timeout(
+                active_request_info,
+                &self.tm_sender,
+                &self.verif_reporter,
+                time_stamp,
+            )
+        }
+    }
+
+    #[derive(Default)]
+    pub struct DummySender {}
+
+    /// Dummy sender component which does nothing on the [Self::send_tm] call.
+    ///
+    /// Useful for unit tests.
+    impl EcssTmSender for DummySender {
+        fn send_tm(&self, _source_id: ComponentId, _tm: PusTmVariant) -> Result<(), EcssTmtcError> {
+            Ok(())
+        }
+    }
+
+    // Testbench dedicated to the testing of [PusTcToRequestConverter]s
+    pub struct PusConverterTestbench<
+        Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
+        ActiveRequestInfo: ActiveRequestProvider,
+        Request,
+    > {
+        pub id: ComponentId,
+        pub verif_reporter: TestVerificationReporter,
+        pub converter: Converter,
+        dummy_sender: DummySender,
+        current_request_id: Option<verification::RequestId>,
+        current_packet: Option<Vec<u8>>,
+        phantom: std::marker::PhantomData<(ActiveRequestInfo, Request)>,
+    }
+
+    impl<
+            Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
+            ActiveRequestInfo: ActiveRequestProvider,
+            Request,
+        > PusConverterTestbench<Converter, ActiveRequestInfo, Request>
+    {
+        pub fn new(owner_id: ComponentId, converter: Converter) -> Self {
+            let test_verif_reporter = TestVerificationReporter::new(owner_id);
+            Self {
+                id: owner_id,
+                verif_reporter: test_verif_reporter,
+                converter,
+                dummy_sender: DummySender::default(),
+                current_request_id: None,
+                current_packet: None,
+                phantom: std::marker::PhantomData,
+            }
+        }
+
+        pub fn add_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+            let token = self.verif_reporter.add_tc(tc);
+            self.current_request_id = Some(verification::RequestId::new(tc));
+            self.current_packet = Some(tc.to_vec().unwrap());
+            self.verif_reporter
+                .acceptance_success(&self.dummy_sender, token, &[])
+                .expect("acceptance failed")
+        }
+
+        pub fn request_id(&self) -> Option<verification::RequestId> {
+            self.current_request_id
+        }
+
+        pub fn convert(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            time_stamp: &[u8],
+            expected_apid: u16,
+            expected_apid_target: u32,
+        ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
+            if self.current_packet.is_none() {
+                return Err(GenericConversionError::InvalidAppData(
+                    "call add_tc first".to_string(),
+                ));
+            }
+            let current_packet = self.current_packet.take().unwrap();
+            let tc_reader = PusTcReader::new(&current_packet).unwrap();
+            let (active_info, request) = self.converter.convert(
+                token,
+                &tc_reader.0,
+                &self.dummy_sender,
+                &self.verif_reporter,
+                time_stamp,
+            )?;
+            assert_eq!(
+                active_info.token().request_id(),
+                self.request_id().expect("no request id is set")
+            );
+            assert_eq!(
+                active_info.target_id(),
+                UniqueApidTargetId::new(expected_apid, expected_apid_target).raw()
+            );
+            Ok((active_info, request))
+        }
+    }
+
+    pub struct TargetedPusRequestTestbench<
+        RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
+        ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
+        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequestProvider,
+        RequestType,
+        ReplyType,
+    > {
+        pub service: PusTargetedRequestService<
+            MpscTcReceiver,
+            MpscTmAsVecSender,
+            EcssTcInVecConverter,
+            TestVerificationReporter,
+            RequestConverter,
+            ReplyHandler,
+            ActiveRequestMap,
+            ActiveRequestInfo,
+            RequestType,
+            ReplyType,
+        >,
+        pub request_id: Option<RequestId>,
+        pub tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+        pub pus_packet_tx: mpsc::Sender<EcssTcAndToken>,
+        pub reply_tx: mpsc::Sender<GenericMessage<ReplyType>>,
+        pub request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
+    }
+}

satrs-example/src/pus/mode.rs

@@ -0,0 +1,435 @@
+use derive_new::new;
+use log::{error, warn};
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use std::sync::mpsc;
+use std::time::Duration;
+
+use crate::requests::GenericRequestRouter;
+use satrs::pool::SharedStaticMemoryPool;
+use satrs::pus::verification::VerificationReporter;
+use satrs::pus::{
+    DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter,
+    EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult,
+    PusServiceHelper,
+};
+use satrs::request::GenericMessage;
+use satrs::{
+    mode::{ModeAndSubmode, ModeReply, ModeRequest},
+    pus::{
+        mode::Subservice,
+        verification::{
+            self, FailParams, TcStateAccepted, TcStateStarted, VerificationReportingProvider,
+            VerificationToken,
+        },
+        ActivePusRequestStd, ActiveRequestProvider, EcssTmSender, EcssTmtcError,
+        GenericConversionError, PusReplyHandler, PusTcToRequestConverter, PusTmVariant,
+    },
+    request::UniqueApidTargetId,
+    spacepackets::{
+        ecss::{
+            tc::PusTcReader,
+            tm::{PusTmCreator, PusTmSecondaryHeader},
+            PusPacket,
+        },
+        SpHeader,
+    },
+    ComponentId,
+};
+use satrs_example::config::components::PUS_MODE_SERVICE;
+use satrs_example::config::{mode_err, tmtc_err};
+
+use super::{
+    create_verification_reporter, generic_pus_request_timeout_handler, HandlingStatus,
+    PusTargetedRequestService, TargetedPusService,
+};
+
+#[derive(new)]
+pub struct ModeReplyHandler {
+    owner_id: ComponentId,
+}
+
+impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
+    type Error = EcssTmtcError;
+
+    fn handle_unrequested_reply(
+        &mut self,
+        reply: &GenericMessage<ModeReply>,
+        _tm_sender: &impl EcssTmSender,
+    ) -> Result<(), Self::Error> {
+        log::warn!("received unexpected reply for mode service 5: {reply:?}");
+        Ok(())
+    }
+
+    fn handle_reply(
+        &mut self,
+        reply: &GenericMessage<ModeReply>,
+        active_request: &ActivePusRequestStd,
+        tm_sender: &impl EcssTmSender,
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<bool, Self::Error> {
+        let started_token: VerificationToken<TcStateStarted> = active_request
+            .token()
+            .try_into()
+            .expect("invalid token state");
+        match reply.message {
+            ModeReply::ModeReply(mode_reply) => {
+                let mut source_data: [u8; 12] = [0; 12];
+                mode_reply
+                    .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(), 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)?;
+            }
+            ModeReply::CantReachMode(error_code) => {
+                verification_handler.completion_failure(
+                    tm_sender,
+                    started_token,
+                    FailParams::new(time_stamp, &error_code, &[]),
+                )?;
+            }
+            ModeReply::WrongMode { expected, reached } => {
+                let mut error_info: [u8; 24] = [0; 24];
+                let mut written_len = expected
+                    .write_to_be_bytes(&mut error_info[0..ModeAndSubmode::RAW_LEN])
+                    .expect("writing expected mode failed");
+                written_len += reached
+                    .write_to_be_bytes(&mut error_info[ModeAndSubmode::RAW_LEN..])
+                    .expect("writing reached mode failed");
+                verification_handler.completion_failure(
+                    tm_sender,
+                    started_token,
+                    FailParams::new(
+                        time_stamp,
+                        &mode_err::WRONG_MODE,
+                        &error_info[..written_len],
+                    ),
+                )?;
+            }
+        };
+        Ok(true)
+    }
+
+    fn handle_request_timeout(
+        &mut self,
+        active_request: &ActivePusRequestStd,
+        tm_sender: &impl EcssTmSender,
+        verification_handler: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<(), Self::Error> {
+        generic_pus_request_timeout_handler(
+            tm_sender,
+            active_request,
+            verification_handler,
+            time_stamp,
+            "HK",
+        )?;
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+pub struct ModeRequestConverter {}
+
+impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestConverter {
+    type Error = GenericConversionError;
+
+    fn convert(
+        &mut self,
+        token: VerificationToken<TcStateAccepted>,
+        tc: &PusTcReader,
+        tm_sender: &(impl EcssTmSender + ?Sized),
+        verif_reporter: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) -> Result<(ActivePusRequestStd, ModeRequest), Self::Error> {
+        let subservice = tc.subservice();
+        let user_data = tc.user_data();
+        let not_enough_app_data = |expected: usize| {
+            verif_reporter
+                .start_failure(
+                    tm_sender,
+                    token,
+                    FailParams::new_no_fail_data(time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA),
+                )
+                .expect("Sending start failure failed");
+            Err(GenericConversionError::NotEnoughAppData {
+                expected,
+                found: user_data.len(),
+            })
+        };
+        if user_data.len() < core::mem::size_of::<u32>() {
+            return not_enough_app_data(4);
+        }
+        let target_id_and_apid = UniqueApidTargetId::from_pus_tc(tc).unwrap();
+        let active_request =
+            ActivePusRequestStd::new(target_id_and_apid.into(), token, Duration::from_secs(30));
+        let subservice_typed = Subservice::try_from(subservice);
+        let invalid_subservice = || {
+            // Invalid subservice
+            verif_reporter
+                .start_failure(
+                    tm_sender,
+                    token,
+                    FailParams::new_no_fail_data(time_stamp, &tmtc_err::INVALID_PUS_SUBSERVICE),
+                )
+                .expect("Sending start failure failed");
+            Err(GenericConversionError::InvalidSubservice(subservice))
+        };
+        if subservice_typed.is_err() {
+            return invalid_subservice();
+        }
+        let subservice_typed = subservice_typed.unwrap();
+        match subservice_typed {
+            Subservice::TcSetMode => {
+                if user_data.len() < core::mem::size_of::<u32>() + ModeAndSubmode::RAW_LEN {
+                    return not_enough_app_data(4 + ModeAndSubmode::RAW_LEN);
+                }
+                let mode_and_submode = ModeAndSubmode::from_be_bytes(&tc.user_data()[4..])
+                    .expect("mode and submode extraction failed");
+                Ok((active_request, ModeRequest::SetMode(mode_and_submode)))
+            }
+            Subservice::TcReadMode => Ok((active_request, ModeRequest::ReadMode)),
+            Subservice::TcAnnounceMode => Ok((active_request, ModeRequest::AnnounceMode)),
+            Subservice::TcAnnounceModeRecursive => {
+                Ok((active_request, ModeRequest::AnnounceModeRecursive))
+            }
+            _ => invalid_subservice(),
+        }
+    }
+}
+
+pub fn create_mode_service_static(
+    tm_sender: PacketSenderWithSharedPool,
+    tc_pool: SharedStaticMemoryPool,
+    pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
+    mode_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<ModeReply>>,
+) -> ModeServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
+    let mode_request_handler = PusTargetedRequestService::new(
+        PusServiceHelper::new(
+            PUS_MODE_SERVICE.id(),
+            pus_action_rx,
+            tm_sender,
+            create_verification_reporter(PUS_MODE_SERVICE.id(), PUS_MODE_SERVICE.apid),
+            EcssTcInSharedStoreConverter::new(tc_pool, 2048),
+        ),
+        ModeRequestConverter::default(),
+        DefaultActiveRequestMap::default(),
+        ModeReplyHandler::new(PUS_MODE_SERVICE.id()),
+        mode_router,
+        reply_receiver,
+    );
+    ModeServiceWrapper {
+        service: mode_request_handler,
+    }
+}
+
+pub fn create_mode_service_dynamic(
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
+    pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
+    mode_router: GenericRequestRouter,
+    reply_receiver: mpsc::Receiver<GenericMessage<ModeReply>>,
+) -> ModeServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
+    let mode_request_handler = PusTargetedRequestService::new(
+        PusServiceHelper::new(
+            PUS_MODE_SERVICE.id(),
+            pus_action_rx,
+            tm_funnel_tx,
+            create_verification_reporter(PUS_MODE_SERVICE.id(), PUS_MODE_SERVICE.apid),
+            EcssTcInVecConverter::default(),
+        ),
+        ModeRequestConverter::default(),
+        DefaultActiveRequestMap::default(),
+        ModeReplyHandler::new(PUS_MODE_SERVICE.id()),
+        mode_router,
+        reply_receiver,
+    );
+    ModeServiceWrapper {
+        service: mode_request_handler,
+    }
+}
+
+pub struct ModeServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
+    pub(crate) service: PusTargetedRequestService<
+        MpscTcReceiver,
+        TmSender,
+        TcInMemConverter,
+        VerificationReporter,
+        ModeRequestConverter,
+        ModeReplyHandler,
+        DefaultActiveRequestMap<ActivePusRequestStd>,
+        ActivePusRequestStd,
+        ModeRequest,
+        ModeReply,
+    >,
+}
+
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> TargetedPusService
+    for ModeServiceWrapper<TmSender, TcInMemConverter>
+{
+    /// Returns [true] if the packet handling is finished.
+    fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self.service.poll_and_handle_next_tc(time_stamp) {
+            Ok(result) => match result {
+                PusPacketHandlerResult::RequestHandled => {}
+                PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
+                    warn!("PUS mode service: partial packet handling success: {e:?}")
+                }
+                PusPacketHandlerResult::CustomSubservice(invalid, _) => {
+                    warn!("PUS mode service: invalid subservice {invalid}");
+                }
+                PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
+                    warn!("PUS mode service: {subservice} not implemented");
+                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+            },
+            Err(error) => {
+                error!("PUS mode service: packet handling error: {error:?}");
+                // To avoid permanent loops on error cases.
+                return HandlingStatus::Empty;
+            }
+        }
+        HandlingStatus::HandledOne
+    }
+
+    fn poll_and_handle_next_reply(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        self.service
+            .poll_and_check_next_reply(time_stamp)
+            .unwrap_or_else(|e| {
+                warn!("PUS action service: Handling reply failed with error {e:?}");
+                HandlingStatus::HandledOne
+            })
+    }
+
+    fn check_for_request_timeouts(&mut self) {
+        self.service.check_for_request_timeouts();
+    }
+}
+#[cfg(test)]
+mod tests {
+    use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
+    use satrs::request::MessageMetadata;
+    use satrs::{
+        mode::{ModeAndSubmode, ModeReply, ModeRequest},
+        pus::mode::Subservice,
+        request::GenericMessage,
+        spacepackets::{
+            ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
+            SpHeader,
+        },
+    };
+    use satrs_example::config::tmtc_err;
+
+    use crate::pus::{
+        mode::ModeReplyHandler,
+        tests::{PusConverterTestbench, ReplyHandlerTestbench},
+    };
+
+    use super::ModeRequestConverter;
+
+    #[test]
+    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, 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.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)
+            .expect("conversion has failed");
+        assert_eq!(req, ModeRequest::ReadMode);
+    }
+
+    #[test]
+    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, 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.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, true);
+        let token = testbench.add_tc(&tc);
+        let (_active_req, req) = testbench
+            .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
+            .expect("conversion has failed");
+        assert_eq!(req, ModeRequest::SetMode(mode_and_submode));
+    }
+
+    #[test]
+    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, 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.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)
+            .expect("conversion has failed");
+        assert_eq!(req, ModeRequest::AnnounceMode);
+    }
+
+    #[test]
+    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, 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.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)
+            .expect("conversion has failed");
+        assert_eq!(req, ModeRequest::AnnounceModeRecursive);
+    }
+
+    #[test]
+    fn reply_handling_unrequested_reply() {
+        let mut testbench = ReplyHandlerTestbench::new(
+            TEST_COMPONENT_ID_0.id(),
+            ModeReplyHandler::new(TEST_COMPONENT_ID_0.id()),
+        );
+        let mode_reply = ModeReply::ModeReply(ModeAndSubmode::new(5, 1));
+        let unrequested_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);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn reply_handling_reply_timeout() {
+        let mut testbench = ReplyHandlerTestbench::new(
+            TEST_COMPONENT_ID_0.id(),
+            ModeReplyHandler::new(TEST_COMPONENT_ID_0.id()),
+        );
+        let (req_id, active_request) = testbench.add_tc(TEST_APID, TEST_UNIQUE_ID_0, &[]);
+        let result = testbench.handle_request_timeout(&active_request, &[]);
+        assert!(result.is_ok());
+        testbench.verif_reporter.assert_completion_failure(
+            TEST_COMPONENT_ID_0.raw(),
+            req_id,
+            None,
+            tmtc_err::REQUEST_TIMEOUT.raw() as u64,
+        );
+    }
+}

satrs-example/src/pus/scheduler.rs

@@ -1,68 +1,89 @@
 use std::sync::mpsc;
 use std::time::Duration;
 
+use crate::pus::create_verification_reporter;
 use log::{error, info, warn};
-use satrs::pool::{PoolProvider, StaticMemoryPool, StoreAddr};
+use satrs::pool::{PoolProvider, StaticMemoryPool};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
-use satrs::pus::scheduler_srv::PusService11SchedHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::scheduler_srv::PusSchedServiceHandler;
+use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    EcssTmSender, MpscTcReceiver, MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
-use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
-use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
+use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
+use satrs::ComponentId;
+use satrs_example::config::components::PUS_SCHED_SERVICE;
 
-use crate::tmtc::PusTcSourceProviderSharedPool;
+use super::HandlingStatus;
 
 pub trait TcReleaser {
-    fn release(&mut self, enabled: bool, info: &TcInfo, tc: &[u8]) -> bool;
+    fn release(&mut self, sender_id: ComponentId, enabled: bool, info: &TcInfo, tc: &[u8]) -> bool;
 }
 
-impl TcReleaser for PusTcSourceProviderSharedPool {
-    fn release(&mut self, enabled: bool, _info: &TcInfo, tc: &[u8]) -> bool {
+impl TcReleaser for PacketSenderWithSharedPool {
+    fn release(
+        &mut self,
+        sender_id: ComponentId,
+        enabled: bool,
+        _info: &TcInfo,
+        tc: &[u8],
+    ) -> bool {
         if enabled {
+            let shared_pool = self.shared_pool.get_mut();
             // Transfer TC from scheduler TC pool to shared TC pool.
-            let released_tc_addr = self
-                .shared_pool
-                .pool
+            let released_tc_addr = shared_pool
+                .0
                 .write()
                 .expect("locking pool failed")
                 .add(tc)
                 .expect("adding TC to shared pool failed");
-            self.tc_source
-                .send(released_tc_addr)
+            self.sender
+                .send(PacketInPool::new(sender_id, released_tc_addr))
                 .expect("sending TC to TC source failed");
         }
         true
     }
 }
 
-impl TcReleaser for mpsc::Sender<Vec<u8>> {
-    fn release(&mut self, enabled: bool, _info: &TcInfo, tc: &[u8]) -> bool {
+impl TcReleaser for mpsc::Sender<PacketAsVec> {
+    fn release(
+        &mut self,
+        sender_id: ComponentId,
+        enabled: bool,
+        _info: &TcInfo,
+        tc: &[u8],
+    ) -> bool {
         if enabled {
             // Send released TC to centralized TC source.
-            self.send(tc.to_vec())
+            self.send(PacketAsVec::new(sender_id, tc.to_vec()))
                 .expect("sending TC to TC source failed");
         }
         true
     }
 }
 
-pub struct Pus11Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_11_handler:
-        PusService11SchedHandler<TcInMemConverter, VerificationReporterWithSender, PusScheduler>,
+pub struct SchedulingServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+{
+    pub pus_11_handler: PusSchedServiceHandler<
+        MpscTcReceiver,
+        TmSender,
+        TcInMemConverter,
+        VerificationReporter,
+        PusScheduler,
+    >,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    SchedulingServiceWrapper<TmSender, TcInMemConverter>
+{
     pub fn release_tcs(&mut self) {
+        let id = self.pus_11_handler.service_helper.id();
         let releaser = |enabled: bool, info: &TcInfo, tc: &[u8]| -> bool {
-            self.tc_releaser.release(enabled, info, tc)
+            self.tc_releaser.release(id, enabled, info, tc)
         };
 
         self.pus_11_handler
@@ -83,8 +104,11 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
         }
     }
 
-    pub fn handle_next_packet(&mut self) -> bool {
-        match self.pus_11_handler.handle_one_tc(&mut self.sched_tc_pool) {
+    pub fn poll_and_handle_next_tc(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        match self
+            .pus_11_handler
+            .poll_and_handle_next_tc(time_stamp, &mut self.sched_tc_pool)
+        {
             Ok(result) => match result {
                 PusPacketHandlerResult::RequestHandled => {}
                 PusPacketHandlerResult::RequestHandledPartialSuccess(e) => {
@@ -96,50 +120,35 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
                 PusPacketHandlerResult::SubserviceNotImplemented(subservice, _) => {
                     warn!("PUS11: Subservice {subservice} not implemented");
                 }
-                PusPacketHandlerResult::Empty => {
-                    return true;
-                }
+                PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
             },
             Err(error) => {
                 error!("PUS packet handling error: {error:?}")
             }
         }
-        false
+        HandlingStatus::HandledOne
     }
 }
 
 pub fn create_scheduler_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
-    tc_releaser: PusTcSourceProviderSharedPool,
+    tm_sender: PacketSenderWithSharedPool,
+    tc_releaser: PacketSenderWithSharedPool,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInSharedStoreConverter> {
-    let sched_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusSched as ChannelId,
-        "PUS_11_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    let sched_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusSched as ChannelId,
-        "PUS_11_TC_RECV",
-        pus_sched_rx,
-    );
+) -> SchedulingServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
     let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
         .expect("Creating PUS Scheduler failed");
-    let pus_11_handler = PusService11SchedHandler::new(
+    let pus_11_handler = PusSchedServiceHandler::new(
         PusServiceHelper::new(
-            Box::new(sched_srv_receiver),
-            Box::new(sched_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
-            EcssTcInSharedStoreConverter::new(tc_releaser.clone_backing_pool(), 2048),
+            PUS_SCHED_SERVICE.id(),
+            pus_sched_rx,
+            tm_sender,
+            create_verification_reporter(PUS_SCHED_SERVICE.id(), PUS_SCHED_SERVICE.apid),
+            EcssTcInSharedStoreConverter::new(tc_releaser.shared_packet_store().0.clone(), 2048),
         ),
         scheduler,
     );
-    Pus11Wrapper {
+    SchedulingServiceWrapper {
         pus_11_handler,
         sched_tc_pool,
         releaser_buf: [0; 4096],
@@ -148,35 +157,26 @@ pub fn create_scheduler_service_static(
 }
 
 pub fn create_scheduler_service_dynamic(
-    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
-    tc_source_sender: mpsc::Sender<Vec<u8>>,
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
+    tc_source_sender: mpsc::Sender<PacketAsVec>,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInVecConverter> {
-    let sched_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusSched as ChannelId,
-        "PUS_11_TM_SENDER",
-        tm_funnel_tx,
-    );
-    let sched_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusSched as ChannelId,
-        "PUS_11_TC_RECV",
-        pus_sched_rx,
-    );
+) -> SchedulingServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
+    //let sched_srv_receiver =
+    //MpscTcReceiver::new(PUS_SCHED_SERVICE.raw(), "PUS_11_TC_RECV", pus_sched_rx);
     let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
         .expect("Creating PUS Scheduler failed");
-    let pus_11_handler = PusService11SchedHandler::new(
+    let pus_11_handler = PusSchedServiceHandler::new(
         PusServiceHelper::new(
-            Box::new(sched_srv_receiver),
-            Box::new(sched_srv_tm_sender),
-            PUS_APID,
-            verif_reporter.clone(),
+            PUS_SCHED_SERVICE.id(),
+            pus_sched_rx,
+            tm_funnel_tx,
+            create_verification_reporter(PUS_SCHED_SERVICE.id(), PUS_SCHED_SERVICE.apid),
             EcssTcInVecConverter::default(),
         ),
         scheduler,
     );
-    Pus11Wrapper {
+    SchedulingServiceWrapper {
         pus_11_handler,
         sched_tc_pool,
         releaser_buf: [0; 4096],

satrs-example/src/pus/stack.rs

@@ -1,50 +1,84 @@
-use satrs::pus::EcssTcInMemConverter;
+use crate::pus::mode::ModeServiceWrapper;
+use derive_new::new;
+use satrs::{
+    pus::{EcssTcInMemConverter, EcssTmSender},
+    spacepackets::time::{cds, TimeWriter},
+};
 
 use super::{
-    action::Pus8Wrapper, event::Pus5Wrapper, hk::Pus3Wrapper, scheduler::Pus11Wrapper,
-    test::Service17CustomWrapper,
+    action::ActionServiceWrapper, event::EventServiceWrapper, hk::HkServiceWrapper,
+    scheduler::SchedulingServiceWrapper, test::TestCustomServiceWrapper, HandlingStatus,
+    TargetedPusService,
 };
 
-pub struct PusStack<TcInMemConverter: EcssTcInMemConverter> {
-    event_srv: Pus5Wrapper<TcInMemConverter>,
-    hk_srv: Pus3Wrapper<TcInMemConverter>,
-    action_srv: Pus8Wrapper<TcInMemConverter>,
-    schedule_srv: Pus11Wrapper<TcInMemConverter>,
-    test_srv: Service17CustomWrapper<TcInMemConverter>,
-}
-
-impl<TcInMemConverter: EcssTcInMemConverter> PusStack<TcInMemConverter> {
-    pub fn new(
-        hk_srv: Pus3Wrapper<TcInMemConverter>,
-        event_srv: Pus5Wrapper<TcInMemConverter>,
-        action_srv: Pus8Wrapper<TcInMemConverter>,
-        schedule_srv: Pus11Wrapper<TcInMemConverter>,
-        test_srv: Service17CustomWrapper<TcInMemConverter>,
-    ) -> Self {
-        Self {
-            event_srv,
-            action_srv,
-            schedule_srv,
-            test_srv,
-            hk_srv,
-        }
+#[derive(new)]
+pub struct PusStack<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter> {
+    test_srv: TestCustomServiceWrapper<TmSender, TcInMemConverter>,
+    hk_srv_wrapper: HkServiceWrapper<TmSender, TcInMemConverter>,
+    event_srv: EventServiceWrapper<TmSender, TcInMemConverter>,
+    action_srv_wrapper: ActionServiceWrapper<TmSender, TcInMemConverter>,
+    schedule_srv: SchedulingServiceWrapper<TmSender, TcInMemConverter>,
+    mode_srv: ModeServiceWrapper<TmSender, TcInMemConverter>,
 }
 
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    PusStack<TmSender, TcInMemConverter>
+{
     pub fn periodic_operation(&mut self) {
+        // Release all telecommands which reached their release time before calling the service
+        // handlers.
         self.schedule_srv.release_tcs();
+        let time_stamp = cds::CdsTime::now_with_u16_days()
+            .expect("time stamp generation error")
+            .to_vec()
+            .unwrap();
         loop {
-            let mut all_queues_empty = true;
-            let mut is_srv_finished = |srv_handler_finished: bool| {
-                if !srv_handler_finished {
-                    all_queues_empty = false;
+            let mut nothing_to_do = true;
+            let mut is_srv_finished =
+                |_srv_id: u8,
+                 tc_handling_status: HandlingStatus,
+                 reply_handling_status: Option<HandlingStatus>| {
+                    if tc_handling_status == HandlingStatus::HandledOne
+                        || (reply_handling_status.is_some()
+                            && reply_handling_status.unwrap() == HandlingStatus::HandledOne)
+                    {
+                        nothing_to_do = false;
                     }
                 };
-            is_srv_finished(self.test_srv.handle_next_packet());
-            is_srv_finished(self.schedule_srv.handle_next_packet());
-            is_srv_finished(self.event_srv.handle_next_packet());
-            is_srv_finished(self.action_srv.handle_next_packet());
-            is_srv_finished(self.hk_srv.handle_next_packet());
-            if all_queues_empty {
+            is_srv_finished(
+                17,
+                self.test_srv.poll_and_handle_next_packet(&time_stamp),
+                None,
+            );
+            is_srv_finished(
+                11,
+                self.schedule_srv.poll_and_handle_next_tc(&time_stamp),
+                None,
+            );
+            is_srv_finished(5, self.event_srv.poll_and_handle_next_tc(&time_stamp), None);
+            is_srv_finished(
+                8,
+                self.action_srv_wrapper.poll_and_handle_next_tc(&time_stamp),
+                Some(
+                    self.action_srv_wrapper
+                        .poll_and_handle_next_reply(&time_stamp),
+                ),
+            );
+            is_srv_finished(
+                3,
+                self.hk_srv_wrapper.poll_and_handle_next_tc(&time_stamp),
+                Some(self.hk_srv_wrapper.poll_and_handle_next_reply(&time_stamp)),
+            );
+            is_srv_finished(
+                200,
+                self.mode_srv.poll_and_handle_next_tc(&time_stamp),
+                Some(self.mode_srv.poll_and_handle_next_reply(&time_stamp)),
+            );
+            if nothing_to_do {
+                // Timeout checking is only done once.
+                self.action_srv_wrapper.check_for_request_timeouts();
+                self.hk_srv_wrapper.check_for_request_timeouts();
+                self.mode_srv.check_for_request_timeouts();
                 break;
             }
         }

satrs-example/src/pus/test.rs

@@ -1,96 +1,77 @@
+use crate::pus::create_verification_reporter;
 use log::{info, warn};
-use satrs::params::Params;
-use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
+use satrs::event_man::{EventMessage, EventMessageU32};
+use satrs::pool::SharedStaticMemoryPool;
 use satrs::pus::test::PusService17TestHandler;
-use satrs::pus::verification::{
-    FailParams, VerificationReporterWithSender, VerificationReportingProvider,
-};
+use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
+use satrs::pus::EcssTcInSharedStoreConverter;
 use satrs::pus::{
-    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
-    MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, EcssTmSender, MpscTcReceiver,
+    MpscTmAsVecSender, PusPacketHandlerResult, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
-use satrs::spacepackets::time::cds::TimeProvider;
+use satrs::spacepackets::time::cds::CdsTime;
 use satrs::spacepackets::time::TimeWriter;
-use satrs::tmtc::tm_helper::SharedTmPool;
-use satrs::ChannelId;
-use satrs::{events::EventU32, pus::EcssTcInSharedStoreConverter};
-use satrs_example::config::{tmtc_err, TcReceiverId, TmSenderId, PUS_APID, TEST_EVENT};
-use std::sync::mpsc::{self, Sender};
+use satrs::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
+use satrs_example::config::components::PUS_TEST_SERVICE;
+use satrs_example::config::{tmtc_err, TEST_EVENT};
+use std::sync::mpsc;
+
+use super::HandlingStatus;
 
 pub fn create_test_service_static(
-    shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_sender: PacketSenderWithSharedPool,
     tc_pool: SharedStaticMemoryPool,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInSharedStoreConverter> {
-    let test_srv_tm_sender = MpscTmInSharedPoolSender::new(
-        TmSenderId::PusTest as ChannelId,
-        "PUS_17_TM_SENDER",
-        shared_tm_store.clone(),
-        tm_funnel_tx.clone(),
-    );
-    let test_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusTest as ChannelId,
-        "PUS_17_TC_RECV",
-        pus_test_rx,
-    );
+) -> TestCustomServiceWrapper<PacketSenderWithSharedPool, EcssTcInSharedStoreConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
-        Box::new(test_srv_receiver),
-        Box::new(test_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
+        PUS_TEST_SERVICE.id(),
+        pus_test_rx,
+        tm_sender,
+        create_verification_reporter(PUS_TEST_SERVICE.id(), PUS_TEST_SERVICE.apid),
         EcssTcInSharedStoreConverter::new(tc_pool, 2048),
     ));
-    Service17CustomWrapper {
-        pus17_handler,
+    TestCustomServiceWrapper {
+        handler: pus17_handler,
         test_srv_event_sender: event_sender,
     }
 }
 
 pub fn create_test_service_dynamic(
-    tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
-    event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
+    tm_funnel_tx: mpsc::Sender<PacketAsVec>,
+    event_sender: mpsc::Sender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInVecConverter> {
-    let test_srv_tm_sender = MpscTmAsVecSender::new(
-        TmSenderId::PusTest as ChannelId,
-        "PUS_17_TM_SENDER",
-        tm_funnel_tx.clone(),
-    );
-    let test_srv_receiver = MpscTcReceiver::new(
-        TcReceiverId::PusTest as ChannelId,
-        "PUS_17_TC_RECV",
-        pus_test_rx,
-    );
+) -> TestCustomServiceWrapper<MpscTmAsVecSender, EcssTcInVecConverter> {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
-        Box::new(test_srv_receiver),
-        Box::new(test_srv_tm_sender),
-        PUS_APID,
-        verif_reporter.clone(),
+        PUS_TEST_SERVICE.id(),
+        pus_test_rx,
+        tm_funnel_tx,
+        create_verification_reporter(PUS_TEST_SERVICE.id(), PUS_TEST_SERVICE.apid),
         EcssTcInVecConverter::default(),
     ));
-    Service17CustomWrapper {
-        pus17_handler,
+    TestCustomServiceWrapper {
+        handler: pus17_handler,
         test_srv_event_sender: event_sender,
     }
 }
 
-pub struct Service17CustomWrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporterWithSender>,
-    pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
+pub struct TestCustomServiceWrapper<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+{
+    pub handler:
+        PusService17TestHandler<MpscTcReceiver, TmSender, TcInMemConverter, VerificationReporter>,
+    pub test_srv_event_sender: mpsc::Sender<EventMessageU32>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConverter> {
-    pub fn handle_next_packet(&mut self) -> bool {
-        let res = self.pus17_handler.handle_one_tc();
+impl<TmSender: EcssTmSender, TcInMemConverter: EcssTcInMemConverter>
+    TestCustomServiceWrapper<TmSender, TcInMemConverter>
+{
+    pub fn poll_and_handle_next_packet(&mut self, time_stamp: &[u8]) -> HandlingStatus {
+        let res = self.handler.poll_and_handle_next_tc(time_stamp);
         if res.is_err() {
             warn!("PUS17 handler failed with error {:?}", res.unwrap_err());
-            return true;
+            return HandlingStatus::HandledOne;
         }
         match res.unwrap() {
             PusPacketHandlerResult::RequestHandled => {
@@ -108,40 +89,42 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
             }
             PusPacketHandlerResult::CustomSubservice(subservice, token) => {
                 let (tc, _) = PusTcReader::new(
-                    self.pus17_handler
+                    self.handler
                         .service_helper
                         .tc_in_mem_converter
                         .tc_slice_raw(),
                 )
                 .unwrap();
-                let time_stamper = TimeProvider::from_now_with_u16_days().unwrap();
+                let time_stamper = CdsTime::now_with_u16_days().unwrap();
                 let mut stamp_buf: [u8; 7] = [0; 7];
                 time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
                 if subservice == 128 {
                     info!("Generating test event");
                     self.test_srv_event_sender
-                        .send((TEST_EVENT.into(), None))
+                        .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
                         .expect("Sending test event failed");
                     let start_token = self
-                        .pus17_handler
+                        .handler
                         .service_helper
-                        .common
-                        .verification_handler
-                        .start_success(token, &stamp_buf)
+                        .verif_reporter()
+                        .start_success(self.handler.service_helper.tm_sender(), token, &stamp_buf)
                         .expect("Error sending start success");
-                    self.pus17_handler
+                    self.handler
                         .service_helper
-                        .common
-                        .verification_handler
-                        .completion_success(start_token, &stamp_buf)
+                        .verif_reporter()
+                        .completion_success(
+                            self.handler.service_helper.tm_sender(),
+                            start_token,
+                            &stamp_buf,
+                        )
                         .expect("Error sending completion success");
                 } else {
                     let fail_data = [tc.subservice()];
-                    self.pus17_handler
+                    self.handler
                         .service_helper
-                        .common
-                        .verification_handler
+                        .verif_reporter()
                         .start_failure(
+                            self.handler.service_helper.tm_sender(),
                             token,
                             FailParams::new(
                                 &stamp_buf,
@@ -152,10 +135,8 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
                         .expect("Sending start failure verification failed");
                 }
             }
-            PusPacketHandlerResult::Empty => {
-                return true;
-            }
-        }
-        false
+            PusPacketHandlerResult::Empty => return HandlingStatus::Empty,
+        }
+        HandlingStatus::HandledOne
     }
 }

satrs-example/src/queue.rs

@@ -1,45 +0,0 @@
-/// Generic error type for sending something via a message queue.
-#[derive(Debug, Copy, Clone)]
-pub enum GenericSendError {
-    RxDisconnected,
-    QueueFull(Option<u32>),
-}
-
-impl Display for GenericSendError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            GenericSendError::RxDisconnected => {
-                write!(f, "rx side has disconnected")
-            }
-            GenericSendError::QueueFull(max_cap) => {
-                write!(f, "queue with max capacity of {max_cap:?} is full")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for GenericSendError {}
-
-/// Generic error type for sending something via a message queue.
-#[derive(Debug, Copy, Clone)]
-pub enum GenericRecvError {
-    Empty,
-    TxDisconnected,
-}
-
-impl Display for GenericRecvError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::TxDisconnected => {
-                write!(f, "tx side has disconnected")
-            }
-            Self::Empty => {
-                write!(f, "nothing to receive")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for GenericRecvError {}

satrs-example/src/requests.rs

@@ -1,94 +1,152 @@
 use std::collections::HashMap;
 use std::sync::mpsc;
 
-use derive_new::new;
+use log::warn;
 use satrs::action::ActionRequest;
 use satrs::hk::HkRequest;
 use satrs::mode::ModeRequest;
-use satrs::pus::action::PusActionRequestRouter;
-use satrs::pus::hk::PusHkRequestRouter;
-use satrs::pus::verification::{TcStateAccepted, VerificationToken};
-use satrs::pus::GenericRoutingError;
+use satrs::pus::verification::{
+    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
+};
+use satrs::pus::{ActiveRequestProvider, EcssTmSender, GenericRoutingError, PusRequestRouter};
 use satrs::queue::GenericSendError;
-use satrs::TargetId;
+use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
+use satrs::spacepackets::ecss::tc::PusTcReader;
+use satrs::spacepackets::ecss::PusPacket;
+use satrs::ComponentId;
+use satrs_example::config::components::PUS_ROUTING_SERVICE;
+use satrs_example::config::tmtc_err;
 
-#[allow(dead_code)]
-#[derive(Clone, Eq, PartialEq, Debug)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
-pub enum Request {
+pub enum CompositeRequest {
     Hk(HkRequest),
-    Mode(ModeRequest),
     Action(ActionRequest),
 }
 
-#[derive(Clone, Eq, PartialEq, Debug, new)]
-pub struct TargetedRequest {
-    pub(crate) target_id: TargetId,
-    pub(crate) request: Request,
+#[derive(Clone)]
+pub struct GenericRequestRouter {
+    pub id: ComponentId,
+    // All messages which do not have a dedicated queue.
+    pub composite_router_map: HashMap<ComponentId, mpsc::Sender<GenericMessage<CompositeRequest>>>,
+    pub mode_router_map: HashMap<ComponentId, mpsc::Sender<GenericMessage<ModeRequest>>>,
 }
 
-#[derive(Clone, Eq, PartialEq, Debug)]
-pub struct RequestWithToken {
-    pub(crate) targeted_request: TargetedRequest,
-    pub(crate) token: VerificationToken<TcStateAccepted>,
-}
-
-impl RequestWithToken {
-    pub fn new(
-        target_id: TargetId,
-        request: Request,
-        token: VerificationToken<TcStateAccepted>,
-    ) -> Self {
+impl Default for GenericRequestRouter {
+    fn default() -> Self {
         Self {
-            targeted_request: TargetedRequest::new(target_id, request),
-            token,
+            id: PUS_ROUTING_SERVICE.raw(),
+            composite_router_map: Default::default(),
+            mode_router_map: Default::default(),
         }
     }
 }
-
-#[derive(Default, Clone)]
-pub struct GenericRequestRouter(pub HashMap<TargetId, mpsc::Sender<RequestWithToken>>);
-
-impl PusHkRequestRouter for GenericRequestRouter {
+impl GenericRequestRouter {
+    pub(crate) fn handle_error_generic(
+        &self,
+        active_request: &impl ActiveRequestProvider,
+        tc: &PusTcReader,
+        error: GenericRoutingError,
+        tm_sender: &(impl EcssTmSender + ?Sized),
+        verif_reporter: &impl VerificationReportingProvider,
+        time_stamp: &[u8],
+    ) {
+        warn!(
+            "Routing request for service {} failed: {error:?}",
+            tc.service()
+        );
+        let accepted_token: VerificationToken<TcStateAccepted> = active_request
+            .token()
+            .try_into()
+            .expect("token is not in accepted state");
+        match error {
+            GenericRoutingError::UnknownTargetId(id) => {
+                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; 8] = [0; 8];
+                fail_data.copy_from_slice(&id.to_be_bytes());
+                verif_reporter
+                    .completion_failure(
+                        tm_sender,
+                        accepted_token,
+                        FailParams::new(time_stamp, &tmtc_err::UNKNOWN_TARGET_ID, &fail_data),
+                    )
+                    .expect("Sending start failure failed");
+            }
+            GenericRoutingError::Send(_) => {
+                let mut fail_data: [u8; 8] = [0; 8];
+                fail_data.copy_from_slice(&active_request.target_id().to_be_bytes());
+                verif_reporter
+                    .completion_failure(
+                        tm_sender,
+                        accepted_token,
+                        FailParams::new(time_stamp, &tmtc_err::ROUTING_ERROR, &fail_data),
+                    )
+                    .expect("Sending start failure failed");
+            }
+        }
+    }
+}
+impl PusRequestRouter<HkRequest> for GenericRequestRouter {
     type Error = GenericRoutingError;
 
     fn route(
         &self,
-        target_id: TargetId,
+        requestor_info: MessageMetadata,
+        target_id: ComponentId,
         hk_request: HkRequest,
-        token: VerificationToken<TcStateAccepted>,
     ) -> Result<(), Self::Error> {
-        if let Some(sender) = self.0.get(&target_id) {
+        if let Some(sender) = self.composite_router_map.get(&target_id) {
             sender
-                .send(RequestWithToken::new(
-                    target_id,
-                    Request::Hk(hk_request),
-                    token,
+                .send(GenericMessage::new(
+                    requestor_info,
+                    CompositeRequest::Hk(hk_request),
                 ))
-                .map_err(|_| GenericRoutingError::SendError(GenericSendError::RxDisconnected))?;
+                .map_err(|_| GenericRoutingError::Send(GenericSendError::RxDisconnected))?;
+            return Ok(());
         }
-        Ok(())
+        Err(GenericRoutingError::UnknownTargetId(target_id))
     }
 }
 
-impl PusActionRequestRouter for GenericRequestRouter {
+impl PusRequestRouter<ActionRequest> for GenericRequestRouter {
     type Error = GenericRoutingError;
 
     fn route(
         &self,
-        target_id: TargetId,
+        requestor_info: MessageMetadata,
+        target_id: ComponentId,
         action_request: ActionRequest,
-        token: VerificationToken<TcStateAccepted>,
     ) -> Result<(), Self::Error> {
-        if let Some(sender) = self.0.get(&target_id) {
+        if let Some(sender) = self.composite_router_map.get(&target_id) {
             sender
-                .send(RequestWithToken::new(
-                    target_id,
-                    Request::Action(action_request),
-                    token,
+                .send(GenericMessage::new(
+                    requestor_info,
+                    CompositeRequest::Action(action_request),
                 ))
-                .map_err(|_| GenericRoutingError::SendError(GenericSendError::RxDisconnected))?;
+                .map_err(|_| GenericRoutingError::Send(GenericSendError::RxDisconnected))?;
+            return Ok(());
         }
-        Ok(())
+        Err(GenericRoutingError::UnknownTargetId(target_id))
+    }
+}
+
+impl PusRequestRouter<ModeRequest> for GenericRequestRouter {
+    type Error = GenericRoutingError;
+
+    fn route(
+        &self,
+        requestor_info: MessageMetadata,
+        target_id: ComponentId,
+        request: ModeRequest,
+    ) -> Result<(), Self::Error> {
+        if let Some(sender) = self.mode_router_map.get(&target_id) {
+            sender
+                .send(GenericMessage::new(requestor_info, request))
+                .map_err(|_| GenericRoutingError::Send(GenericSendError::RxDisconnected))?;
+            return Ok(());
+        }
+        Err(GenericRoutingError::UnknownTargetId(target_id))
     }
 }

satrs-example/src/tmtc.rs

@@ -1,207 +0,0 @@
-use log::warn;
-use satrs::pus::{EcssTcAndToken, ReceivesEcssPusTc};
-use satrs::spacepackets::SpHeader;
-use std::sync::mpsc::{self, Receiver, SendError, Sender, TryRecvError};
-use thiserror::Error;
-
-use crate::pus::PusReceiver;
-use satrs::pool::{PoolProvider, SharedStaticMemoryPool, StoreAddr, StoreError};
-use satrs::spacepackets::ecss::tc::PusTcReader;
-use satrs::spacepackets::ecss::PusPacket;
-use satrs::tmtc::ReceivesCcsdsTc;
-
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
-pub enum MpscStoreAndSendError {
-    #[error("Store error: {0}")]
-    Store(#[from] StoreError),
-    #[error("TC send error: {0}")]
-    TcSend(#[from] SendError<EcssTcAndToken>),
-    #[error("TMTC send error: {0}")]
-    TmTcSend(#[from] SendError<StoreAddr>),
-}
-
-#[derive(Clone)]
-pub struct SharedTcPool {
-    pub pool: SharedStaticMemoryPool,
-}
-
-impl SharedTcPool {
-    pub fn add_pus_tc(&mut self, pus_tc: &PusTcReader) -> Result<StoreAddr, StoreError> {
-        let mut pg = self.pool.write().expect("error locking TC store");
-        let addr = pg.free_element(pus_tc.len_packed(), |buf| {
-            buf[0..pus_tc.len_packed()].copy_from_slice(pus_tc.raw_data());
-        })?;
-        Ok(addr)
-    }
-}
-
-#[derive(Clone)]
-pub struct PusTcSourceProviderSharedPool {
-    pub tc_source: Sender<StoreAddr>,
-    pub shared_pool: SharedTcPool,
-}
-
-impl PusTcSourceProviderSharedPool {
-    #[allow(dead_code)]
-    pub fn clone_backing_pool(&self) -> SharedStaticMemoryPool {
-        self.shared_pool.pool.clone()
-    }
-}
-
-impl ReceivesEcssPusTc for PusTcSourceProviderSharedPool {
-    type Error = MpscStoreAndSendError;
-
-    fn pass_pus_tc(&mut self, _: &SpHeader, pus_tc: &PusTcReader) -> Result<(), Self::Error> {
-        let addr = self.shared_pool.add_pus_tc(pus_tc)?;
-        self.tc_source.send(addr)?;
-        Ok(())
-    }
-}
-
-impl ReceivesCcsdsTc for PusTcSourceProviderSharedPool {
-    type Error = MpscStoreAndSendError;
-
-    fn pass_ccsds(&mut self, _: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> {
-        let mut pool = self.shared_pool.pool.write().expect("locking pool failed");
-        let addr = pool.add(tc_raw)?;
-        drop(pool);
-        self.tc_source.send(addr)?;
-        Ok(())
-    }
-}
-
-// Newtype, can not implement necessary traits on MPSC sender directly because of orphan rules.
-#[derive(Clone)]
-pub struct PusTcSourceProviderDynamic(pub Sender<Vec<u8>>);
-
-impl ReceivesEcssPusTc for PusTcSourceProviderDynamic {
-    type Error = SendError<Vec<u8>>;
-
-    fn pass_pus_tc(&mut self, _: &SpHeader, pus_tc: &PusTcReader) -> Result<(), Self::Error> {
-        self.0.send(pus_tc.raw_data().to_vec())?;
-        Ok(())
-    }
-}
-
-impl ReceivesCcsdsTc for PusTcSourceProviderDynamic {
-    type Error = mpsc::SendError<Vec<u8>>;
-
-    fn pass_ccsds(&mut self, _: &SpHeader, tc_raw: &[u8]) -> Result<(), Self::Error> {
-        self.0.send(tc_raw.to_vec())?;
-        Ok(())
-    }
-}
-
-// TC source components where static pools are the backing memory of the received telecommands.
-pub struct TcSourceTaskStatic {
-    shared_tc_pool: SharedTcPool,
-    tc_receiver: Receiver<StoreAddr>,
-    tc_buf: [u8; 4096],
-    pus_receiver: PusReceiver,
-}
-
-impl TcSourceTaskStatic {
-    pub fn new(
-        shared_tc_pool: SharedTcPool,
-        tc_receiver: Receiver<StoreAddr>,
-        pus_receiver: PusReceiver,
-    ) -> Self {
-        Self {
-            shared_tc_pool,
-            tc_receiver,
-            tc_buf: [0; 4096],
-            pus_receiver,
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.poll_tc();
-    }
-
-    pub fn poll_tc(&mut self) -> bool {
-        match self.tc_receiver.try_recv() {
-            Ok(addr) => {
-                let pool = self
-                    .shared_tc_pool
-                    .pool
-                    .read()
-                    .expect("locking tc pool failed");
-                pool.read(&addr, &mut self.tc_buf)
-                    .expect("reading pool failed");
-                drop(pool);
-                match PusTcReader::new(&self.tc_buf) {
-                    Ok((pus_tc, _)) => {
-                        self.pus_receiver
-                            .handle_tc_packet(
-                                satrs::pus::TcInMemory::StoreAddr(addr),
-                                pus_tc.service(),
-                                &pus_tc,
-                            )
-                            .ok();
-                        true
-                    }
-                    Err(e) => {
-                        warn!("error creating PUS TC from raw data: {e}");
-                        warn!("raw data: {:x?}", self.tc_buf);
-                        true
-                    }
-                }
-            }
-            Err(e) => match e {
-                TryRecvError::Empty => false,
-                TryRecvError::Disconnected => {
-                    warn!("tmtc thread: sender disconnected");
-                    false
-                }
-            },
-        }
-    }
-}
-
-// TC source components where the heap is the backing memory of the received telecommands.
-pub struct TcSourceTaskDynamic {
-    pub tc_receiver: Receiver<Vec<u8>>,
-    pus_receiver: PusReceiver,
-}
-
-impl TcSourceTaskDynamic {
-    pub fn new(tc_receiver: Receiver<Vec<u8>>, pus_receiver: PusReceiver) -> Self {
-        Self {
-            tc_receiver,
-            pus_receiver,
-        }
-    }
-
-    pub fn periodic_operation(&mut self) {
-        self.poll_tc();
-    }
-
-    pub fn poll_tc(&mut self) -> bool {
-        match self.tc_receiver.try_recv() {
-            Ok(tc) => match PusTcReader::new(&tc) {
-                Ok((pus_tc, _)) => {
-                    self.pus_receiver
-                        .handle_tc_packet(
-                            satrs::pus::TcInMemory::Vec(tc.clone()),
-                            pus_tc.service(),
-                            &pus_tc,
-                        )
-                        .ok();
-                    true
-                }
-                Err(e) => {
-                    warn!("error creating PUS TC from raw data: {e}");
-                    warn!("raw data: {:x?}", tc);
-                    true
-                }
-            },
-            Err(e) => match e {
-                TryRecvError::Empty => false,
-                TryRecvError::Disconnected => {
-                    warn!("tmtc thread: sender disconnected");
-                    false
-                }
-            },
-        }
-    }
-}

satrs-example/src/tmtc/mod.rs

@@ -0,0 +1,2 @@
+pub mod tc_source;
+pub mod tm_sink;

satrs-example/src/tmtc/tc_source.rs

@@ -0,0 +1,106 @@
+use satrs::{
+    pool::PoolProvider,
+    tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool},
+};
+use std::sync::mpsc::{self, TryRecvError};
+
+use satrs::pus::MpscTmAsVecSender;
+
+use crate::pus::{HandlingStatus, PusTcDistributor};
+
+// 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>,
+    tc_buf: [u8; 4096],
+    pus_distributor: PusTcDistributor<PacketSenderWithSharedPool>,
+}
+
+impl TcSourceTaskStatic {
+    pub fn new(
+        shared_tc_pool: SharedPacketPool,
+        tc_receiver: mpsc::Receiver<PacketInPool>,
+        pus_receiver: PusTcDistributor<PacketSenderWithSharedPool>,
+    ) -> Self {
+        Self {
+            shared_tc_pool,
+            tc_receiver,
+            tc_buf: [0; 4096],
+            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_in_pool) => {
+                let pool = self
+                    .shared_tc_pool
+                    .0
+                    .read()
+                    .expect("locking tc pool failed");
+                pool.read(&packet_in_pool.store_addr, &mut self.tc_buf)
+                    .expect("reading pool failed");
+                drop(pool);
+                self.pus_distributor
+                    .handle_tc_packet_in_store(packet_in_pool, &self.tc_buf)
+                    .ok();
+                HandlingStatus::HandledOne
+            }
+            Err(e) => match e {
+                TryRecvError::Empty => HandlingStatus::Empty,
+                TryRecvError::Disconnected => {
+                    log::warn!("tmtc thread: sender disconnected");
+                    HandlingStatus::Empty
+                }
+            },
+        }
+    }
+}
+
+// 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<MpscTmAsVecSender>,
+}
+
+impl TcSourceTaskDynamic {
+    pub fn new(
+        tc_receiver: mpsc::Receiver<PacketAsVec>,
+        pus_receiver: PusTcDistributor<MpscTmAsVecSender>,
+    ) -> 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
+                }
+            },
+        }
+    }
+}

satrs-example/src/tmtc/tm_sink.rs

@@ -1,21 +1,21 @@
 use std::{
     collections::HashMap,
-    sync::mpsc::{Receiver, Sender},
+    sync::mpsc::{self},
 };
 
 use log::info;
+use satrs::tmtc::{PacketAsVec, PacketInPool, SharedPacketPool};
 use satrs::{
-    pool::{PoolProvider, StoreAddr},
+    pool::PoolProvider,
     seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProviderCore},
     spacepackets::{
         ecss::{tm::PusTmZeroCopyWriter, PusPacket},
         time::cds::MIN_CDS_FIELD_LEN,
         CcsdsPacket,
     },
-    tmtc::tm_helper::SharedTmPool,
 };
 
-use crate::tcp::SyncTcpTmSource;
+use crate::interface::tcp::SyncTcpTmSource;
 
 #[derive(Default)]
 pub struct CcsdsSeqCounterMap {
@@ -76,17 +76,17 @@ impl TmFunnelCommon {
 
 pub struct TmFunnelStatic {
     common: TmFunnelCommon,
-    shared_tm_store: SharedTmPool,
-    tm_funnel_rx: Receiver<StoreAddr>,
-    tm_server_tx: Sender<StoreAddr>,
+    shared_tm_store: SharedPacketPool,
+    tm_funnel_rx: mpsc::Receiver<PacketInPool>,
+    tm_server_tx: mpsc::SyncSender<PacketInPool>,
 }
 
 impl TmFunnelStatic {
     pub fn new(
-        shared_tm_store: SharedTmPool,
+        shared_tm_store: SharedPacketPool,
         sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: Receiver<StoreAddr>,
-        tm_server_tx: Sender<StoreAddr>,
+        tm_funnel_rx: mpsc::Receiver<PacketInPool>,
+        tm_server_tx: mpsc::SyncSender<PacketInPool>,
     ) -> Self {
         Self {
             common: TmFunnelCommon::new(sync_tm_tcp_source),
@@ -97,14 +97,14 @@ impl TmFunnelStatic {
     }
 
     pub fn operation(&mut self) {
-        if let Ok(addr) = self.tm_funnel_rx.recv() {
+        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.clone_backing_pool();
+            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(&addr, |buf| {
+                .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);
@@ -112,7 +112,7 @@ impl TmFunnelStatic {
                 })
                 .expect("Reading TM from pool failed");
             self.tm_server_tx
-                .send(addr)
+                .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.
@@ -123,15 +123,15 @@ impl TmFunnelStatic {
 
 pub struct TmFunnelDynamic {
     common: TmFunnelCommon,
-    tm_funnel_rx: Receiver<Vec<u8>>,
-    tm_server_tx: Sender<Vec<u8>>,
+    tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+    tm_server_tx: mpsc::Sender<PacketAsVec>,
 }
 
 impl TmFunnelDynamic {
     pub fn new(
         sync_tm_tcp_source: SyncTcpTmSource,
-        tm_funnel_rx: Receiver<Vec<u8>>,
-        tm_server_tx: Sender<Vec<u8>>,
+        tm_funnel_rx: mpsc::Receiver<PacketAsVec>,
+        tm_server_tx: mpsc::Sender<PacketAsVec>,
     ) -> Self {
         Self {
             common: TmFunnelCommon::new(sync_tm_tcp_source),
@@ -144,13 +144,13 @@ impl TmFunnelDynamic {
         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, MIN_CDS_FIELD_LEN)
+            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.clone())
+                .send(tm)
                 .expect("Sending TM to server failed");
-            self.common.sync_tm_tcp_source.add_tm(&tm);
         }
     }
 }

satrs-mib/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.1.2] 2024-04-17
+
+Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
+
 # [v0.1.1] 2024-02-17
 
 - Bumped `spacepackets` to v0.10.0

satrs-mib/Cargo.toml

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

satrs-mib/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib-codegen"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 description = "satrs-mib proc macro implementation"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
@@ -26,7 +26,9 @@ features = ["full"]
 
 [dev-dependencies]
 trybuild = { version = "1", features = ["diff"] }
-satrs-shared = "0.1.2"
+
+[dev-dependencies.satrs-shared]
+version = ">=0.1.3, <0.2"
 
 [dev-dependencies.satrs-mib]
 path = ".."

satrs-minisim/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "satrs-minisim"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+log = "0.4"
+thiserror = "1"
+
+[dependencies.asynchronix]
+version = "0.2.1"
+
+[dependencies.satrs]
+path = "../satrs"
+
+[dev-dependencies]
+delegate = "0.12"

satrs-minisim/src/acs.rs

@@ -0,0 +1,338 @@
+use std::{f32::consts::PI, sync::mpsc, time::Duration};
+
+use asynchronix::{
+    model::{Model, Output},
+    time::Scheduler,
+};
+use satrs::power::SwitchStateBinary;
+use satrs_minisim::{
+    acs::{MgmReply, MgmSensorValues, MgtDipole, MgtHkSet, MgtReply, MGT_GEN_MAGNETIC_FIELD},
+    SimReply,
+};
+
+use crate::time::current_millis;
+
+// Earth magnetic field varies between -30 uT and 30 uT
+const AMPLITUDE_MGM: f32 = 0.03;
+// Lets start with a simple frequency here.
+const FREQUENCY_MGM: f32 = 1.0;
+const PHASE_X: f32 = 0.0;
+// Different phases to have different values on the other axes.
+const PHASE_Y: f32 = 0.1;
+const PHASE_Z: f32 = 0.2;
+
+/// Simple model for a magnetometer where the measure magnetic fields are modeled with sine waves.
+///
+/// Please note that that a more realistic MGM model wouold include the following components
+/// which are not included here to simplify the model:
+///
+/// 1. It would probably generate signed [i16] values which need to be converted to SI units
+///    because it is a digital sensor
+/// 2. It would sample the magnetic field at a high fixed rate. This might not be possible for
+///    a general purpose OS, but self self-sampling at a relatively high rate (20-40 ms) might
+///    stil lbe possible.
+pub struct MagnetometerModel {
+    pub switch_state: SwitchStateBinary,
+    pub periodicity: Duration,
+    pub external_mag_field: Option<MgmSensorValues>,
+    pub reply_sender: mpsc::Sender<SimReply>,
+}
+
+impl MagnetometerModel {
+    pub fn new(periodicity: Duration, reply_sender: mpsc::Sender<SimReply>) -> Self {
+        Self {
+            switch_state: SwitchStateBinary::Off,
+            periodicity,
+            external_mag_field: None,
+            reply_sender,
+        }
+    }
+
+    pub async fn switch_device(&mut self, switch_state: SwitchStateBinary) {
+        self.switch_state = switch_state;
+    }
+
+    pub async fn send_sensor_values(&mut self, _: (), scheduler: &Scheduler<Self>) {
+        self.reply_sender
+            .send(SimReply::new(MgmReply {
+                switch_state: self.switch_state,
+                sensor_values: self.calculate_current_mgm_tuple(current_millis(scheduler.time())),
+            }))
+            .expect("sending MGM sensor values failed");
+    }
+
+    // Devices like magnetorquers generate a strong magnetic field which overrides the default
+    // model for the measured magnetic field.
+    pub async fn apply_external_magnetic_field(&mut self, field: MgmSensorValues) {
+        self.external_mag_field = Some(field);
+    }
+
+    fn calculate_current_mgm_tuple(&self, time_ms: u64) -> MgmSensorValues {
+        if SwitchStateBinary::On == self.switch_state {
+            if let Some(ext_field) = self.external_mag_field {
+                return ext_field;
+            }
+            let base_sin_val = 2.0 * PI * FREQUENCY_MGM * (time_ms as f32 / 1000.0);
+            return MgmSensorValues {
+                x: AMPLITUDE_MGM * (base_sin_val + PHASE_X).sin(),
+                y: AMPLITUDE_MGM * (base_sin_val + PHASE_Y).sin(),
+                z: AMPLITUDE_MGM * (base_sin_val + PHASE_Z).sin(),
+            };
+        }
+        MgmSensorValues {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        }
+    }
+}
+
+impl Model for MagnetometerModel {}
+
+pub struct MagnetorquerModel {
+    switch_state: SwitchStateBinary,
+    torquing: bool,
+    torque_dipole: MgtDipole,
+    pub gen_magnetic_field: Output<MgmSensorValues>,
+    reply_sender: mpsc::Sender<SimReply>,
+}
+
+impl MagnetorquerModel {
+    pub fn new(reply_sender: mpsc::Sender<SimReply>) -> Self {
+        Self {
+            switch_state: SwitchStateBinary::Off,
+            torquing: false,
+            torque_dipole: MgtDipole::default(),
+            gen_magnetic_field: Output::new(),
+            reply_sender,
+        }
+    }
+
+    pub async fn apply_torque(
+        &mut self,
+        duration_and_dipole: (Duration, MgtDipole),
+        scheduler: &Scheduler<Self>,
+    ) {
+        self.torque_dipole = duration_and_dipole.1;
+        self.torquing = true;
+        if scheduler
+            .schedule_event(duration_and_dipole.0, Self::clear_torque, ())
+            .is_err()
+        {
+            log::warn!("torque clearing can only be set for a future time.");
+        }
+        self.generate_magnetic_field(()).await;
+    }
+
+    pub async fn clear_torque(&mut self, _: ()) {
+        self.torque_dipole = MgtDipole::default();
+        self.torquing = false;
+        self.generate_magnetic_field(()).await;
+    }
+
+    pub async fn switch_device(&mut self, switch_state: SwitchStateBinary) {
+        self.switch_state = switch_state;
+        self.generate_magnetic_field(()).await;
+    }
+
+    pub async fn request_housekeeping_data(&mut self, _: (), scheduler: &Scheduler<Self>) {
+        if self.switch_state != SwitchStateBinary::On {
+            return;
+        }
+        scheduler
+            .schedule_event(Duration::from_millis(15), Self::send_housekeeping_data, ())
+            .expect("requesting housekeeping data failed")
+    }
+
+    pub fn send_housekeeping_data(&mut self) {
+        self.reply_sender
+            .send(SimReply::new(MgtReply::Hk(MgtHkSet {
+                dipole: self.torque_dipole,
+                torquing: self.torquing,
+            })))
+            .unwrap();
+    }
+
+    fn calc_magnetic_field(&self, _: MgtDipole) -> MgmSensorValues {
+        // Simplified model: Just returns some fixed magnetic field for now.
+        // Later, we could make this more fancy by incorporating the commanded dipole.
+        MGT_GEN_MAGNETIC_FIELD
+    }
+
+    /// A torquing magnetorquer generates a magnetic field. This function can be used to apply
+    /// the magnetic field.
+    async fn generate_magnetic_field(&mut self, _: ()) {
+        if self.switch_state != SwitchStateBinary::On || !self.torquing {
+            return;
+        }
+        self.gen_magnetic_field
+            .send(self.calc_magnetic_field(self.torque_dipole))
+            .await;
+    }
+}
+
+impl Model for MagnetorquerModel {}
+
+#[cfg(test)]
+pub mod tests {
+    use std::time::Duration;
+
+    use satrs::power::SwitchStateBinary;
+    use satrs_minisim::{
+        acs::{MgmReply, MgmRequest, MgtDipole, MgtHkSet, MgtReply, MgtRequest},
+        eps::PcduSwitch,
+        SerializableSimMsgPayload, SimMessageProvider, SimRequest, SimTarget,
+    };
+
+    use crate::{eps::tests::switch_device_on, test_helpers::SimTestbench};
+
+    #[test]
+    fn test_basic_mgm_request() {
+        let mut sim_testbench = SimTestbench::new();
+        let request = SimRequest::new(MgmRequest::RequestSensorData);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply.is_some());
+        let sim_reply = sim_reply.unwrap();
+        assert_eq!(sim_reply.target(), SimTarget::Mgm);
+        let reply = MgmReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        assert_eq!(reply.switch_state, SwitchStateBinary::Off);
+        assert_eq!(reply.sensor_values.x, 0.0);
+        assert_eq!(reply.sensor_values.y, 0.0);
+        assert_eq!(reply.sensor_values.z, 0.0);
+    }
+
+    #[test]
+    fn test_basic_mgm_request_switched_on() {
+        let mut sim_testbench = SimTestbench::new();
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgm);
+
+        let mut request = SimRequest::new(MgmRequest::RequestSensorData);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let mut sim_reply_res = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply_res.is_some());
+        let mut sim_reply = sim_reply_res.unwrap();
+        assert_eq!(sim_reply.target(), SimTarget::Mgm);
+        let first_reply = MgmReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        sim_testbench.step_by(Duration::from_millis(50));
+
+        request = SimRequest::new(MgmRequest::RequestSensorData);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        sim_reply_res = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply_res.is_some());
+        sim_reply = sim_reply_res.unwrap();
+
+        let second_reply = MgmReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        // Check that the values are changing.
+        assert!(first_reply != second_reply);
+    }
+
+    #[test]
+    fn test_basic_mgt_request_is_off() {
+        let mut sim_testbench = SimTestbench::new();
+        let request = SimRequest::new(MgtRequest::RequestHk);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply_res = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply_res.is_none());
+    }
+
+    #[test]
+    fn test_basic_mgt_request_is_on() {
+        let mut sim_testbench = SimTestbench::new();
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgt);
+        let request = SimRequest::new(MgtRequest::RequestHk);
+
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply_res = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply_res.is_some());
+        let sim_reply = sim_reply_res.unwrap();
+        let mgt_reply = MgtReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        match mgt_reply {
+            MgtReply::Hk(hk) => {
+                assert_eq!(hk.dipole, MgtDipole::default());
+                assert!(!hk.torquing);
+            }
+            _ => panic!("unexpected reply"),
+        }
+    }
+
+    fn check_mgt_hk(sim_testbench: &mut SimTestbench, expected_hk_set: MgtHkSet) {
+        let request = SimRequest::new(MgtRequest::RequestHk);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply_res = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply_res.is_some());
+        let sim_reply = sim_reply_res.unwrap();
+        let mgt_reply = MgtReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        match mgt_reply {
+            MgtReply::Hk(hk) => {
+                assert_eq!(hk, expected_hk_set);
+            }
+            _ => panic!("unexpected reply"),
+        }
+    }
+
+    #[test]
+    fn test_basic_mgt_request_is_on_and_torquing() {
+        let mut sim_testbench = SimTestbench::new();
+        switch_device_on(&mut sim_testbench, PcduSwitch::Mgt);
+        let commanded_dipole = MgtDipole {
+            x: -200,
+            y: 200,
+            z: 1000,
+        };
+        let request = SimRequest::new(MgtRequest::ApplyTorque {
+            duration: Duration::from_millis(100),
+            dipole: commanded_dipole,
+        });
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step_by(Duration::from_millis(5));
+
+        check_mgt_hk(
+            &mut sim_testbench,
+            MgtHkSet {
+                dipole: commanded_dipole,
+                torquing: true,
+            },
+        );
+        sim_testbench.step_by(Duration::from_millis(100));
+        check_mgt_hk(
+            &mut sim_testbench,
+            MgtHkSet {
+                dipole: MgtDipole::default(),
+                torquing: false,
+            },
+        );
+    }
+}

satrs-minisim/src/controller.rs

@@ -0,0 +1,189 @@
+use std::{sync::mpsc, time::Duration};
+
+use asynchronix::{
+    simulation::{Address, Simulation},
+    time::{Clock, MonotonicTime, SystemClock},
+};
+use satrs_minisim::{
+    acs::{MgmRequest, MgtRequest},
+    eps::PcduRequest,
+    SerializableSimMsgPayload, SimCtrlReply, SimCtrlRequest, SimMessageProvider, SimReply,
+    SimRequest, SimRequestError, SimTarget,
+};
+
+use crate::{
+    acs::{MagnetometerModel, MagnetorquerModel},
+    eps::PcduModel,
+};
+
+// The simulation controller processes requests and drives the simulation.
+pub struct SimController {
+    pub sys_clock: SystemClock,
+    pub request_receiver: mpsc::Receiver<SimRequest>,
+    pub reply_sender: mpsc::Sender<SimReply>,
+    pub simulation: Simulation,
+    pub mgm_addr: Address<MagnetometerModel>,
+    pub pcdu_addr: Address<PcduModel>,
+    pub mgt_addr: Address<MagnetorquerModel>,
+}
+
+impl SimController {
+    pub fn new(
+        sys_clock: SystemClock,
+        request_receiver: mpsc::Receiver<SimRequest>,
+        reply_sender: mpsc::Sender<SimReply>,
+        simulation: Simulation,
+        mgm_addr: Address<MagnetometerModel>,
+        pcdu_addr: Address<PcduModel>,
+        mgt_addr: Address<MagnetorquerModel>,
+    ) -> Self {
+        Self {
+            sys_clock,
+            request_receiver,
+            reply_sender,
+            simulation,
+            mgm_addr,
+            pcdu_addr,
+            mgt_addr,
+        }
+    }
+
+    pub fn run(&mut self, start_time: MonotonicTime, udp_polling_interval_ms: u64) {
+        let mut t = start_time + Duration::from_millis(udp_polling_interval_ms);
+        self.sys_clock.synchronize(t);
+        loop {
+            // Check for UDP requests every millisecond. Shift the simulator ahead here to prevent
+            // replies lying in the past.
+            t += Duration::from_millis(udp_polling_interval_ms);
+            self.simulation
+                .step_until(t)
+                .expect("simulation step failed");
+            self.handle_sim_requests();
+
+            self.sys_clock.synchronize(t);
+        }
+    }
+
+    pub fn handle_sim_requests(&mut self) {
+        loop {
+            match self.request_receiver.try_recv() {
+                Ok(request) => {
+                    if let Err(e) = match request.target() {
+                        SimTarget::SimCtrl => self.handle_ctrl_request(&request),
+                        SimTarget::Mgm => self.handle_mgm_request(&request),
+                        SimTarget::Mgt => self.handle_mgt_request(&request),
+                        SimTarget::Pcdu => self.handle_pcdu_request(&request),
+                    } {
+                        self.handle_invalid_request_with_valid_target(e, &request)
+                    }
+                }
+                Err(e) => match e {
+                    mpsc::TryRecvError::Empty => break,
+                    mpsc::TryRecvError::Disconnected => {
+                        panic!("all request sender disconnected")
+                    }
+                },
+            }
+        }
+    }
+
+    fn handle_ctrl_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
+        let sim_ctrl_request = SimCtrlRequest::from_sim_message(request)?;
+        match sim_ctrl_request {
+            SimCtrlRequest::Ping => {
+                self.reply_sender
+                    .send(SimReply::new(SimCtrlReply::Pong))
+                    .expect("sending reply from sim controller failed");
+            }
+        }
+        Ok(())
+    }
+    fn handle_mgm_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
+        let mgm_request = MgmRequest::from_sim_message(request)?;
+        match mgm_request {
+            MgmRequest::RequestSensorData => {
+                self.simulation.send_event(
+                    MagnetometerModel::send_sensor_values,
+                    (),
+                    &self.mgm_addr,
+                );
+            }
+        }
+        Ok(())
+    }
+
+    fn handle_pcdu_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
+        let pcdu_request = PcduRequest::from_sim_message(request)?;
+        match pcdu_request {
+            PcduRequest::RequestSwitchInfo => {
+                self.simulation
+                    .send_event(PcduModel::request_switch_info, (), &self.pcdu_addr);
+            }
+            PcduRequest::SwitchDevice { switch, state } => {
+                self.simulation.send_event(
+                    PcduModel::switch_device,
+                    (switch, state),
+                    &self.pcdu_addr,
+                );
+            }
+        }
+        Ok(())
+    }
+
+    fn handle_mgt_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
+        let mgt_request = MgtRequest::from_sim_message(request)?;
+        match mgt_request {
+            MgtRequest::ApplyTorque { duration, dipole } => self.simulation.send_event(
+                MagnetorquerModel::apply_torque,
+                (duration, dipole),
+                &self.mgt_addr,
+            ),
+            MgtRequest::RequestHk => self.simulation.send_event(
+                MagnetorquerModel::request_housekeeping_data,
+                (),
+                &self.mgt_addr,
+            ),
+        }
+        Ok(())
+    }
+
+    fn handle_invalid_request_with_valid_target(
+        &self,
+        error: SimRequestError,
+        request: &SimRequest,
+    ) {
+        log::warn!(
+            "received invalid {:?} request: {:?}",
+            request.target(),
+            error
+        );
+        self.reply_sender
+            .send(SimReply::new(SimCtrlReply::from(error)))
+            .expect("sending reply from sim controller failed");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_helpers::SimTestbench;
+
+    use super::*;
+
+    #[test]
+    fn test_basic_ping() {
+        let mut sim_testbench = SimTestbench::new();
+        let request = SimRequest::new(SimCtrlRequest::Ping);
+        sim_testbench
+            .send_request(request)
+            .expect("sending sim ctrl request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply.is_some());
+        let sim_reply = sim_reply.unwrap();
+        assert_eq!(sim_reply.target(), SimTarget::SimCtrl);
+        let reply = SimCtrlReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize MGM sensor values");
+        assert_eq!(reply, SimCtrlReply::Pong);
+    }
+}

satrs-minisim/src/eps.rs

@@ -0,0 +1,185 @@
+use std::{collections::HashMap, sync::mpsc, time::Duration};
+
+use asynchronix::{
+    model::{Model, Output},
+    time::Scheduler,
+};
+use satrs::power::SwitchStateBinary;
+use satrs_minisim::{
+    eps::{PcduReply, PcduSwitch, SwitchMap},
+    SimReply,
+};
+
+pub const SWITCH_INFO_DELAY_MS: u64 = 10;
+
+pub struct PcduModel {
+    pub switcher_map: SwitchMap,
+    pub mgm_switch: Output<SwitchStateBinary>,
+    pub mgt_switch: Output<SwitchStateBinary>,
+    pub reply_sender: mpsc::Sender<SimReply>,
+}
+
+impl PcduModel {
+    pub fn new(reply_sender: mpsc::Sender<SimReply>) -> Self {
+        let mut switcher_map = HashMap::new();
+        switcher_map.insert(PcduSwitch::Mgm, SwitchStateBinary::Off);
+        switcher_map.insert(PcduSwitch::Mgt, SwitchStateBinary::Off);
+
+        Self {
+            switcher_map,
+            mgm_switch: Output::new(),
+            mgt_switch: Output::new(),
+            reply_sender,
+        }
+    }
+
+    pub async fn request_switch_info(&mut self, _: (), scheduler: &Scheduler<Self>) {
+        scheduler
+            .schedule_event(
+                Duration::from_millis(SWITCH_INFO_DELAY_MS),
+                Self::send_switch_info,
+                (),
+            )
+            .expect("requesting switch info failed");
+    }
+
+    pub fn send_switch_info(&mut self) {
+        let reply = SimReply::new(PcduReply::SwitchInfo(self.switcher_map.clone()));
+        self.reply_sender.send(reply).unwrap();
+    }
+
+    pub async fn switch_device(
+        &mut self,
+        switch_and_target_state: (PcduSwitch, SwitchStateBinary),
+    ) {
+        let val = self
+            .switcher_map
+            .get_mut(&switch_and_target_state.0)
+            .unwrap_or_else(|| panic!("switch {:?} not found", switch_and_target_state.0));
+        *val = switch_and_target_state.1;
+        match switch_and_target_state.0 {
+            PcduSwitch::Mgm => {
+                self.mgm_switch.send(switch_and_target_state.1).await;
+            }
+            PcduSwitch::Mgt => {
+                self.mgt_switch.send(switch_and_target_state.1).await;
+            }
+        }
+    }
+}
+
+impl Model for PcduModel {}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    use satrs_minisim::{
+        eps::PcduRequest, SerializableSimMsgPayload, SimMessageProvider, SimRequest, SimTarget,
+    };
+
+    use crate::test_helpers::SimTestbench;
+
+    fn switch_device(
+        sim_testbench: &mut SimTestbench,
+        switch: PcduSwitch,
+        target: SwitchStateBinary,
+    ) {
+        let request = SimRequest::new(PcduRequest::SwitchDevice {
+            switch,
+            state: target,
+        });
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM switch request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+    }
+
+    #[allow(dead_code)]
+    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: PcduSwitch) {
+        switch_device(sim_testbench, switch, SwitchStateBinary::On);
+    }
+
+    pub(crate) fn get_all_off_switch_map() -> SwitchMap {
+        let mut switcher_map = SwitchMap::new();
+        switcher_map.insert(super::PcduSwitch::Mgm, super::SwitchStateBinary::Off);
+        switcher_map.insert(super::PcduSwitch::Mgt, super::SwitchStateBinary::Off);
+        switcher_map
+    }
+
+    fn check_switch_state(sim_testbench: &mut SimTestbench, expected_switch_map: &SwitchMap) {
+        let request = SimRequest::new(PcduRequest::RequestSwitchInfo);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step();
+        let sim_reply = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply.is_some());
+        let sim_reply = sim_reply.unwrap();
+        assert_eq!(sim_reply.target(), SimTarget::Pcdu);
+        let pcdu_reply = PcduReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize PCDU switch info");
+        match pcdu_reply {
+            PcduReply::SwitchInfo(switch_map) => {
+                assert_eq!(switch_map, *expected_switch_map);
+            }
+        }
+    }
+
+    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();
+        *switcher_map.get_mut(&switch).unwrap() = target;
+        check_switch_state(&mut sim_testbench, &switcher_map);
+    }
+
+    #[test]
+    fn test_pcdu_switcher_request() {
+        let mut sim_testbench = SimTestbench::new();
+        let request = SimRequest::new(PcduRequest::RequestSwitchInfo);
+        sim_testbench
+            .send_request(request)
+            .expect("sending MGM request failed");
+        sim_testbench.handle_sim_requests();
+        sim_testbench.step_by(Duration::from_millis(1));
+
+        let sim_reply = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply.is_none());
+        // Reply takes 20ms
+        sim_testbench.step_by(Duration::from_millis(25));
+        let sim_reply = sim_testbench.try_receive_next_reply();
+        assert!(sim_reply.is_some());
+        let sim_reply = sim_reply.unwrap();
+        assert_eq!(sim_reply.target(), SimTarget::Pcdu);
+        let pcdu_reply = PcduReply::from_sim_message(&sim_reply)
+            .expect("failed to deserialize PCDU switch info");
+        match pcdu_reply {
+            PcduReply::SwitchInfo(switch_map) => {
+                assert_eq!(switch_map, get_all_off_switch_map());
+            }
+        }
+    }
+
+    #[test]
+    fn test_pcdu_switching_mgm_on() {
+        test_pcdu_switching_single_switch(PcduSwitch::Mgm, SwitchStateBinary::On);
+    }
+
+    #[test]
+    fn test_pcdu_switching_mgt_on() {
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::On);
+    }
+
+    #[test]
+    fn test_pcdu_switching_mgt_off() {
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::On);
+        test_pcdu_switching_single_switch(PcduSwitch::Mgt, SwitchStateBinary::Off);
+    }
+}

satrs-minisim/src/lib.rs

@@ -0,0 +1,383 @@
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SimTarget {
+    SimCtrl,
+    Mgm,
+    Mgt,
+    Pcdu,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SimMessage {
+    pub target: SimTarget,
+    pub payload: String,
+}
+
+/// A generic simulation request type. Right now, the payload data is expected to be
+/// JSON, which might be changed in the future.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SimRequest {
+    inner: SimMessage,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SimMessageType {
+    Request,
+    Reply,
+}
+
+/// Generic trait implemented by simulation request or reply payloads. It ties the request or
+/// reply to a specific target and provides an API which does boilerplate tasks like checking the
+/// validity of the target.
+pub trait SerializableSimMsgPayload<P: SimMessageProvider>:
+    Serialize + DeserializeOwned + Sized
+{
+    const TARGET: SimTarget;
+
+    fn from_sim_message(sim_message: &P) -> Result<Self, SimMessageError<P>> {
+        if sim_message.target() == Self::TARGET {
+            return Ok(serde_json::from_str(sim_message.payload())?);
+        }
+        Err(SimMessageError::TargetRequestMissmatch(sim_message.clone()))
+    }
+}
+
+pub trait SimMessageProvider: Serialize + DeserializeOwned + Clone + Sized {
+    fn msg_type(&self) -> SimMessageType;
+    fn target(&self) -> SimTarget;
+    fn payload(&self) -> &String;
+    fn from_raw_data(data: &[u8]) -> serde_json::Result<Self> {
+        serde_json::from_slice(data)
+    }
+}
+
+impl SimRequest {
+    pub fn new<T: SerializableSimMsgPayload<SimRequest>>(serializable_request: T) -> Self {
+        Self {
+            inner: SimMessage {
+                target: T::TARGET,
+                payload: serde_json::to_string(&serializable_request).unwrap(),
+            },
+        }
+    }
+}
+
+impl SimMessageProvider for SimRequest {
+    fn target(&self) -> SimTarget {
+        self.inner.target
+    }
+    fn payload(&self) -> &String {
+        &self.inner.payload
+    }
+
+    fn msg_type(&self) -> SimMessageType {
+        SimMessageType::Request
+    }
+}
+
+/// A generic simulation reply type. Right now, the payload data is expected to be
+/// JSON, which might be changed inthe future.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SimReply {
+    inner: SimMessage,
+}
+
+impl SimReply {
+    pub fn new<T: SerializableSimMsgPayload<SimReply>>(serializable_reply: T) -> Self {
+        Self {
+            inner: SimMessage {
+                target: T::TARGET,
+                payload: serde_json::to_string(&serializable_reply).unwrap(),
+            },
+        }
+    }
+}
+
+impl SimMessageProvider for SimReply {
+    fn target(&self) -> SimTarget {
+        self.inner.target
+    }
+    fn payload(&self) -> &String {
+        &self.inner.payload
+    }
+    fn msg_type(&self) -> SimMessageType {
+        SimMessageType::Reply
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SimCtrlRequest {
+    Ping,
+}
+
+impl SerializableSimMsgPayload<SimRequest> for SimCtrlRequest {
+    const TARGET: SimTarget = SimTarget::SimCtrl;
+}
+
+pub type SimReplyError = SimMessageError<SimReply>;
+pub type SimRequestError = SimMessageError<SimRequest>;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SimMessageError<P> {
+    SerdeJson(String),
+    TargetRequestMissmatch(P),
+}
+
+impl<P> From<serde_json::Error> for SimMessageError<P> {
+    fn from(error: serde_json::Error) -> SimMessageError<P> {
+        SimMessageError::SerdeJson(error.to_string())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SimCtrlReply {
+    Pong,
+    InvalidRequest(SimRequestError),
+}
+
+impl SerializableSimMsgPayload<SimReply> for SimCtrlReply {
+    const TARGET: SimTarget = SimTarget::SimCtrl;
+}
+
+impl From<SimRequestError> for SimCtrlReply {
+    fn from(error: SimRequestError) -> Self {
+        SimCtrlReply::InvalidRequest(error)
+    }
+}
+
+pub mod eps {
+    use super::*;
+    use std::collections::HashMap;
+
+    use satrs::power::SwitchStateBinary;
+
+    pub type SwitchMap = HashMap<PcduSwitch, SwitchStateBinary>;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+    pub enum PcduSwitch {
+        Mgm = 0,
+        Mgt = 1,
+    }
+
+    #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+    pub enum PcduRequest {
+        SwitchDevice {
+            switch: PcduSwitch,
+            state: SwitchStateBinary,
+        },
+        RequestSwitchInfo,
+    }
+
+    impl SerializableSimMsgPayload<SimRequest> for PcduRequest {
+        const TARGET: SimTarget = SimTarget::Pcdu;
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub enum PcduReply {
+        SwitchInfo(SwitchMap),
+    }
+
+    impl SerializableSimMsgPayload<SimReply> for PcduReply {
+        const TARGET: SimTarget = SimTarget::Pcdu;
+    }
+}
+
+pub mod acs {
+    use std::time::Duration;
+
+    use satrs::power::SwitchStateBinary;
+
+    use super::*;
+
+    #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+    pub enum MgmRequest {
+        RequestSensorData,
+    }
+
+    impl SerializableSimMsgPayload<SimRequest> for MgmRequest {
+        const TARGET: SimTarget = SimTarget::Mgm;
+    }
+
+    // Normally, small magnetometers generate their output as a signed 16 bit raw format or something
+    // similar which needs to be converted to a signed float value with physical units. We will
+    // simplify this now and generate the signed float values directly.
+    #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
+    pub struct MgmSensorValues {
+        pub x: f32,
+        pub y: f32,
+        pub z: f32,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
+    pub struct MgmReply {
+        pub switch_state: SwitchStateBinary,
+        pub sensor_values: MgmSensorValues,
+    }
+
+    impl SerializableSimMsgPayload<SimReply> for MgmReply {
+        const TARGET: SimTarget = SimTarget::Mgm;
+    }
+
+    pub const MGT_GEN_MAGNETIC_FIELD: MgmSensorValues = MgmSensorValues {
+        x: 0.03,
+        y: -0.03,
+        z: 0.03,
+    };
+
+    // Simple model using i16 values.
+    #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    pub struct MgtDipole {
+        pub x: i16,
+        pub y: i16,
+        pub z: i16,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
+    pub enum MgtRequestType {
+        ApplyTorque,
+    }
+
+    #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+    pub enum MgtRequest {
+        ApplyTorque {
+            duration: Duration,
+            dipole: MgtDipole,
+        },
+        RequestHk,
+    }
+
+    impl SerializableSimMsgPayload<SimRequest> for MgtRequest {
+        const TARGET: SimTarget = SimTarget::Mgt;
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    pub struct MgtHkSet {
+        pub dipole: MgtDipole,
+        pub torquing: bool,
+    }
+
+    #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+    pub enum MgtReply {
+        Ack(MgtRequestType),
+        Nak(MgtRequestType),
+        Hk(MgtHkSet),
+    }
+
+    impl SerializableSimMsgPayload<SimReply> for MgtReply {
+        const TARGET: SimTarget = SimTarget::Mgm;
+    }
+}
+
+pub mod udp {
+    use std::{
+        net::{SocketAddr, UdpSocket},
+        time::Duration,
+    };
+
+    use thiserror::Error;
+
+    use crate::{SimReply, SimRequest};
+
+    #[derive(Error, Debug)]
+    pub enum ReceptionError {
+        #[error("IO error: {0}")]
+        Io(#[from] std::io::Error),
+        #[error("Serde JSON error: {0}")]
+        SerdeJson(#[from] serde_json::Error),
+    }
+
+    pub struct SimUdpClient {
+        socket: UdpSocket,
+        pub reply_buf: [u8; 4096],
+    }
+
+    impl SimUdpClient {
+        pub fn new(
+            server_addr: &SocketAddr,
+            non_blocking: bool,
+            read_timeot_ms: Option<u64>,
+        ) -> std::io::Result<Self> {
+            let socket = UdpSocket::bind("127.0.0.1:0")?;
+            socket.set_nonblocking(non_blocking)?;
+            socket
+                .connect(server_addr)
+                .expect("could not connect to server addr");
+            if let Some(read_timeout) = read_timeot_ms {
+                // Set a read timeout so the test does not hang on failures.
+                socket.set_read_timeout(Some(Duration::from_millis(read_timeout)))?;
+            }
+            Ok(Self {
+                socket,
+                reply_buf: [0; 4096],
+            })
+        }
+
+        pub fn set_nonblocking(&self, non_blocking: bool) -> std::io::Result<()> {
+            self.socket.set_nonblocking(non_blocking)
+        }
+
+        pub fn set_read_timeout(&self, read_timeout_ms: u64) -> std::io::Result<()> {
+            self.socket
+                .set_read_timeout(Some(Duration::from_millis(read_timeout_ms)))
+        }
+
+        pub fn send_request(&self, sim_request: &SimRequest) -> std::io::Result<usize> {
+            self.socket.send(
+                &serde_json::to_vec(sim_request).expect("conversion of request to vector failed"),
+            )
+        }
+
+        pub fn recv_raw(&mut self) -> std::io::Result<usize> {
+            self.socket.recv(&mut self.reply_buf)
+        }
+
+        pub fn recv_sim_reply(&mut self) -> Result<SimReply, ReceptionError> {
+            let read_len = self.recv_raw()?;
+            Ok(serde_json::from_slice(&self.reply_buf[0..read_len])?)
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    pub enum DummyRequest {
+        Ping,
+    }
+
+    impl SerializableSimMsgPayload<SimRequest> for DummyRequest {
+        const TARGET: SimTarget = SimTarget::SimCtrl;
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+    pub enum DummyReply {
+        Pong,
+    }
+
+    impl SerializableSimMsgPayload<SimReply> for DummyReply {
+        const TARGET: SimTarget = SimTarget::SimCtrl;
+    }
+
+    #[test]
+    fn test_basic_request() {
+        let sim_request = SimRequest::new(DummyRequest::Ping);
+        assert_eq!(sim_request.target(), SimTarget::SimCtrl);
+        assert_eq!(sim_request.msg_type(), SimMessageType::Request);
+        let dummy_request =
+            DummyRequest::from_sim_message(&sim_request).expect("deserialization failed");
+        assert_eq!(dummy_request, DummyRequest::Ping);
+    }
+
+    #[test]
+    fn test_basic_reply() {
+        let sim_reply = SimReply::new(DummyReply::Pong);
+        assert_eq!(sim_reply.target(), SimTarget::SimCtrl);
+        assert_eq!(sim_reply.msg_type(), SimMessageType::Reply);
+        let dummy_request =
+            DummyReply::from_sim_message(&sim_reply).expect("deserialization failed");
+        assert_eq!(dummy_request, DummyReply::Pong);
+    }
+}

satrs-minisim/src/main.rs

@@ -0,0 +1,103 @@
+use acs::{MagnetometerModel, MagnetorquerModel};
+use asynchronix::simulation::{Mailbox, SimInit};
+use asynchronix::time::{MonotonicTime, SystemClock};
+use controller::SimController;
+use eps::PcduModel;
+use satrs_minisim::{SimReply, SimRequest};
+use std::sync::mpsc;
+use std::thread;
+use std::time::{Duration, SystemTime};
+use udp::SimUdpServer;
+
+mod acs;
+mod controller;
+mod eps;
+#[cfg(test)]
+mod test_helpers;
+mod time;
+mod udp;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ThreadingModel {
+    Default = 0,
+    Single = 1,
+}
+
+fn create_sim_controller(
+    threading_model: ThreadingModel,
+    start_time: MonotonicTime,
+    reply_sender: mpsc::Sender<SimReply>,
+    request_receiver: mpsc::Receiver<SimRequest>,
+) -> SimController {
+    // Instantiate models and their mailboxes.
+    let mgm_model = MagnetometerModel::new(Duration::from_millis(50), reply_sender.clone());
+
+    let mgm_mailbox = Mailbox::new();
+    let mgm_addr = mgm_mailbox.address();
+    let pcdu_mailbox = Mailbox::new();
+    let pcdu_addr = pcdu_mailbox.address();
+    let mgt_mailbox = Mailbox::new();
+    let mgt_addr = mgt_mailbox.address();
+
+    let mut pcdu_model = PcduModel::new(reply_sender.clone());
+    pcdu_model
+        .mgm_switch
+        .connect(MagnetometerModel::switch_device, &mgm_addr);
+
+    let mut mgt_model = MagnetorquerModel::new(reply_sender.clone());
+    // Input connections.
+    pcdu_model
+        .mgt_switch
+        .connect(MagnetorquerModel::switch_device, &mgt_addr);
+    // Output connections.
+    mgt_model
+        .gen_magnetic_field
+        .connect(MagnetometerModel::apply_external_magnetic_field, &mgm_addr);
+
+    // Instantiate the simulator
+    let sys_clock = SystemClock::from_system_time(start_time, SystemTime::now());
+    let sim_init = if threading_model == ThreadingModel::Single {
+        SimInit::with_num_threads(1)
+    } else {
+        SimInit::new()
+    };
+    let simulation = sim_init
+        .add_model(mgm_model, mgm_mailbox)
+        .add_model(pcdu_model, pcdu_mailbox)
+        .add_model(mgt_model, mgt_mailbox)
+        .init(start_time);
+    SimController::new(
+        sys_clock,
+        request_receiver,
+        reply_sender,
+        simulation,
+        mgm_addr,
+        pcdu_addr,
+        mgt_addr,
+    )
+}
+
+fn main() {
+    let (request_sender, request_receiver) = mpsc::channel();
+    let (reply_sender, reply_receiver) = mpsc::channel();
+    let t0 = MonotonicTime::EPOCH;
+    let mut sim_ctrl =
+        create_sim_controller(ThreadingModel::Default, t0, reply_sender, request_receiver);
+
+    // This thread schedules the simulator.
+    let sim_thread = thread::spawn(move || {
+        sim_ctrl.run(t0, 1);
+    });
+
+    let mut udp_server = SimUdpServer::new(0, request_sender, reply_receiver, 200, None)
+        .expect("could not create UDP request server");
+    // This thread manages the simulator UDP server.
+    let udp_tc_thread = thread::spawn(move || {
+        udp_server.run();
+    });
+
+    sim_thread.join().expect("joining simulation thread failed");
+    udp_tc_thread
+        .join()
+        .expect("joining UDP server thread failed");
+}

satrs-minisim/src/test_helpers.rs

@@ -0,0 +1,56 @@
+use delegate::delegate;
+use std::{sync::mpsc, time::Duration};
+
+use asynchronix::time::MonotonicTime;
+use satrs_minisim::{SimReply, SimRequest};
+
+use crate::{controller::SimController, create_sim_controller, ThreadingModel};
+
+pub struct SimTestbench {
+    pub sim_controller: SimController,
+    pub reply_receiver: mpsc::Receiver<SimReply>,
+    pub request_sender: mpsc::Sender<SimRequest>,
+}
+
+impl SimTestbench {
+    pub fn new() -> Self {
+        let (request_sender, request_receiver) = mpsc::channel();
+        let (reply_sender, reply_receiver) = mpsc::channel();
+        let t0 = MonotonicTime::EPOCH;
+        let sim_ctrl =
+            create_sim_controller(ThreadingModel::Single, t0, reply_sender, request_receiver);
+
+        Self {
+            sim_controller: sim_ctrl,
+            reply_receiver,
+            request_sender,
+        }
+    }
+
+    delegate! {
+        to self.sim_controller {
+            pub fn handle_sim_requests(&mut self);
+        }
+        to self.sim_controller.simulation {
+            pub fn step(&mut self);
+            pub fn step_by(&mut self, duration: Duration);
+        }
+    }
+
+    pub fn send_request(&self, request: SimRequest) -> Result<(), mpsc::SendError<SimRequest>> {
+        self.request_sender.send(request)
+    }
+
+    pub fn try_receive_next_reply(&self) -> Option<SimReply> {
+        match self.reply_receiver.try_recv() {
+            Ok(reply) => Some(reply),
+            Err(e) => {
+                if e == mpsc::TryRecvError::Empty {
+                    None
+                } else {
+                    panic!("reply_receiver disconnected");
+                }
+            }
+        }
+    }
+}

satrs-minisim/src/time.rs

@@ -0,0 +1,5 @@
+use asynchronix::time::MonotonicTime;
+
+pub fn current_millis(time: MonotonicTime) -> u64 {
+    (time.as_secs() as u64 * 1000) + (time.subsec_nanos() as u64 / 1_000_000)
+}

satrs-minisim/src/udp.rs

@@ -0,0 +1,390 @@
+use std::{
+    collections::VecDeque,
+    io::ErrorKind,
+    net::{SocketAddr, UdpSocket},
+    sync::{atomic::AtomicBool, mpsc, Arc},
+    time::Duration,
+};
+
+use satrs_minisim::{SimMessageProvider, SimReply, SimRequest};
+
+// A UDP server which handles all TC received by a client application.
+pub struct SimUdpServer {
+    socket: UdpSocket,
+    request_sender: mpsc::Sender<SimRequest>,
+    // shared_last_sender: SharedSocketAddr,
+    reply_receiver: mpsc::Receiver<SimReply>,
+    reply_queue: VecDeque<SimReply>,
+    max_num_replies: usize,
+    // Stop signal to stop the server. Required for unittests and useful to allow clean shutdown
+    // of the application.
+    stop_signal: Option<Arc<AtomicBool>>,
+    idle_sleep_period_ms: u64,
+    req_buf: [u8; 4096],
+    sender_addr: Option<SocketAddr>,
+}
+
+impl SimUdpServer {
+    pub fn new(
+        local_port: u16,
+        request_sender: mpsc::Sender<SimRequest>,
+        reply_receiver: mpsc::Receiver<SimReply>,
+        max_num_replies: usize,
+        stop_signal: Option<Arc<AtomicBool>>,
+    ) -> std::io::Result<Self> {
+        let socket = UdpSocket::bind(SocketAddr::from(([0, 0, 0, 0], local_port)))?;
+        socket.set_nonblocking(true)?;
+        Ok(Self {
+            socket,
+            request_sender,
+            reply_receiver,
+            reply_queue: VecDeque::new(),
+            max_num_replies,
+            stop_signal,
+            idle_sleep_period_ms: 3,
+            req_buf: [0; 4096],
+            sender_addr: None,
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn server_addr(&self) -> std::io::Result<SocketAddr> {
+        self.socket.local_addr()
+    }
+
+    pub fn run(&mut self) {
+        loop {
+            if let Some(stop_signal) = &self.stop_signal {
+                if stop_signal.load(std::sync::atomic::Ordering::Relaxed) {
+                    break;
+                }
+            }
+            let processed_requests = self.process_requests();
+            let processed_replies = self.process_replies();
+            let sent_replies = self.send_replies();
+            // Sleep for a bit if there is nothing to do to prevent burning CPU cycles. Delay
+            // should be kept short to ensure responsiveness of the system.
+            if !processed_requests && !processed_replies && !sent_replies {
+                std::thread::sleep(Duration::from_millis(self.idle_sleep_period_ms));
+            }
+        }
+    }
+
+    fn process_requests(&mut self) -> bool {
+        let mut processed_requests = false;
+        loop {
+            // Blocks for a certain amount of time until data is received to allow doing periodic
+            // work like checking the stop signal.
+            let (bytes_read, src) = match self.socket.recv_from(&mut self.req_buf) {
+                Ok((bytes_read, src)) => (bytes_read, src),
+                Err(e) if e.kind() == ErrorKind::WouldBlock => {
+                    // Continue to perform regular checks like the stop signal.
+                    break;
+                }
+                Err(e) => {
+                    // Handle unexpected errors (e.g., socket closed) here.
+                    log::error!("unexpected request server error: {e}");
+                    break;
+                }
+            };
+
+            self.sender_addr = Some(src);
+
+            let sim_req = SimRequest::from_raw_data(&self.req_buf[..bytes_read]);
+            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();
+            processed_requests = true;
+        }
+        processed_requests
+    }
+
+    fn process_replies(&mut self) -> bool {
+        let mut processed_replies = false;
+        loop {
+            match self.reply_receiver.try_recv() {
+                Ok(reply) => {
+                    if self.reply_queue.len() >= self.max_num_replies {
+                        self.reply_queue.pop_front();
+                    }
+                    self.reply_queue.push_back(reply);
+                    processed_replies = true;
+                }
+                Err(e) => match e {
+                    mpsc::TryRecvError::Empty => return processed_replies,
+                    mpsc::TryRecvError::Disconnected => {
+                        log::error!("all UDP reply senders disconnected")
+                    }
+                },
+            }
+        }
+    }
+
+    fn send_replies(&mut self) -> bool {
+        if self.sender_addr.is_none() {
+            return false;
+        }
+        let mut sent_replies = false;
+        while !self.reply_queue.is_empty() {
+            let next_reply_to_send = self.reply_queue.pop_front().unwrap();
+            self.socket
+                .send_to(
+                    serde_json::to_string(&next_reply_to_send)
+                        .unwrap()
+                        .as_bytes(),
+                    self.sender_addr.unwrap(),
+                )
+                .expect("sending reply failed");
+            sent_replies = true;
+        }
+        sent_replies
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        io::ErrorKind,
+        sync::{
+            atomic::{AtomicBool, Ordering},
+            mpsc, Arc,
+        },
+        time::Duration,
+    };
+
+    use satrs_minisim::{
+        eps::{PcduReply, PcduRequest},
+        udp::{ReceptionError, SimUdpClient},
+        SimCtrlReply, SimCtrlRequest, SimReply, SimRequest,
+    };
+
+    use crate::eps::tests::get_all_off_switch_map;
+    use delegate::delegate;
+
+    use super::SimUdpServer;
+
+    // Wait time to ensure even possibly laggy systems like CI servers can run the tests.
+    const SERVER_WAIT_TIME_MS: u64 = 50;
+
+    struct UdpTestbench {
+        client: SimUdpClient,
+        stop_signal: Arc<AtomicBool>,
+        request_receiver: mpsc::Receiver<SimRequest>,
+        reply_sender: mpsc::Sender<SimReply>,
+    }
+
+    impl UdpTestbench {
+        pub fn new(
+            client_non_blocking: bool,
+            client_read_timeout_ms: Option<u64>,
+            max_num_replies: usize,
+        ) -> std::io::Result<(Self, SimUdpServer)> {
+            let (request_sender, request_receiver) = mpsc::channel();
+            let (reply_sender, reply_receiver) = mpsc::channel();
+            let stop_signal = Arc::new(AtomicBool::new(false));
+            let server = SimUdpServer::new(
+                0,
+                request_sender,
+                reply_receiver,
+                max_num_replies,
+                Some(stop_signal.clone()),
+            )?;
+            let server_addr = server.server_addr()?;
+            Ok((
+                Self {
+                    client: SimUdpClient::new(
+                        &server_addr,
+                        client_non_blocking,
+                        client_read_timeout_ms,
+                    )?,
+                    stop_signal,
+                    request_receiver,
+                    reply_sender,
+                },
+                server,
+            ))
+        }
+
+        pub fn try_recv_request(&self) -> Result<SimRequest, mpsc::TryRecvError> {
+            self.request_receiver.try_recv()
+        }
+
+        pub fn stop(&self) {
+            self.stop_signal.store(true, Ordering::Relaxed);
+        }
+
+        pub fn send_reply(&self, sim_reply: &SimReply) {
+            self.reply_sender
+                .send(sim_reply.clone())
+                .expect("sending sim reply failed");
+        }
+
+        delegate! {
+            to self.client {
+                pub fn send_request(&self, sim_request: &SimRequest) -> std::io::Result<usize>;
+                pub fn recv_sim_reply(&mut self) -> Result<SimReply, ReceptionError>;
+            }
+        }
+
+        pub fn check_no_sim_reply_available(&mut self) {
+            if let Err(ReceptionError::Io(ref io_error)) = self.recv_sim_reply() {
+                if io_error.kind() == ErrorKind::WouldBlock {
+                    // Continue to perform regular checks like the stop signal.
+                    return;
+                } else {
+                    // Handle unexpected errors (e.g., socket closed) here.
+                    panic!("unexpected request server error: {io_error}");
+                }
+            }
+            panic!("unexpected reply available");
+        }
+
+        pub fn check_next_sim_reply(&mut self, expected_reply: &SimReply) {
+            match self.recv_sim_reply() {
+                Ok(received_sim_reply) => assert_eq!(expected_reply, &received_sim_reply),
+                Err(e) => match e {
+                    ReceptionError::Io(ref io_error) => {
+                        if io_error.kind() == ErrorKind::WouldBlock {
+                            // Continue to perform regular checks like the stop signal.
+                            panic!("no simulation reply received");
+                        } else {
+                            // Handle unexpected errors (e.g., socket closed) here.
+                            panic!("unexpected request server error: {e}");
+                        }
+                    }
+                    ReceptionError::SerdeJson(json_error) => {
+                        panic!("unexpected JSON error: {json_error}");
+                    }
+                },
+            }
+        }
+    }
+    #[test]
+    fn test_basic_udp_request_reception() {
+        let (udp_testbench, mut udp_server) =
+            UdpTestbench::new(true, Some(SERVER_WAIT_TIME_MS), 10)
+                .expect("could not create testbench");
+        let server_thread = std::thread::spawn(move || udp_server.run());
+        let sim_request = SimRequest::new(PcduRequest::RequestSwitchInfo);
+        udp_testbench
+            .send_request(&sim_request)
+            .expect("sending request failed");
+        std::thread::sleep(Duration::from_millis(SERVER_WAIT_TIME_MS));
+        // Check that the sim request has arrives and was forwarded.
+        let received_sim_request = udp_testbench
+            .try_recv_request()
+            .expect("did not receive request");
+        assert_eq!(sim_request, received_sim_request);
+        // Stop the server.
+        udp_testbench.stop();
+        server_thread.join().unwrap();
+    }
+
+    #[test]
+    fn test_udp_reply_server() {
+        let (mut udp_testbench, mut udp_server) =
+            UdpTestbench::new(false, Some(SERVER_WAIT_TIME_MS), 10)
+                .expect("could not create testbench");
+        let server_thread = std::thread::spawn(move || udp_server.run());
+        udp_testbench
+            .send_request(&SimRequest::new(SimCtrlRequest::Ping))
+            .expect("sending request failed");
+
+        let sim_reply = SimReply::new(PcduReply::SwitchInfo(get_all_off_switch_map()));
+        udp_testbench.send_reply(&sim_reply);
+
+        udp_testbench.check_next_sim_reply(&sim_reply);
+
+        // Stop the server.
+        udp_testbench.stop();
+        server_thread.join().unwrap();
+    }
+
+    #[test]
+    fn test_udp_req_server_and_reply_sender() {
+        let (mut udp_testbench, mut udp_server) =
+            UdpTestbench::new(false, Some(SERVER_WAIT_TIME_MS), 10)
+                .expect("could not create testbench");
+
+        let server_thread = std::thread::spawn(move || udp_server.run());
+
+        // Send a ping so that the server knows the address of the client.
+        // Do not check that the request arrives on the receiver side, is done by other test.
+        udp_testbench
+            .send_request(&SimRequest::new(SimCtrlRequest::Ping))
+            .expect("sending request failed");
+
+        // Send a reply to the server, ensure it gets forwarded to the client.
+        let sim_reply = SimReply::new(PcduReply::SwitchInfo(get_all_off_switch_map()));
+        udp_testbench.send_reply(&sim_reply);
+        std::thread::sleep(Duration::from_millis(SERVER_WAIT_TIME_MS));
+
+        // Now we check that the reply server can send back replies to the client.
+        udp_testbench.check_next_sim_reply(&sim_reply);
+
+        udp_testbench.stop();
+        server_thread.join().unwrap();
+    }
+
+    #[test]
+    fn test_udp_replies_client_unconnected() {
+        let (mut udp_testbench, mut udp_server) =
+            UdpTestbench::new(true, None, 10).expect("could not create testbench");
+
+        let server_thread = std::thread::spawn(move || udp_server.run());
+
+        // Send a reply to the server. The client is not connected, so it won't get forwarded.
+        let sim_reply = SimReply::new(PcduReply::SwitchInfo(get_all_off_switch_map()));
+        udp_testbench.send_reply(&sim_reply);
+        std::thread::sleep(Duration::from_millis(10));
+
+        udp_testbench.check_no_sim_reply_available();
+
+        // Connect by sending a ping.
+        udp_testbench
+            .send_request(&SimRequest::new(SimCtrlRequest::Ping))
+            .expect("sending request failed");
+        std::thread::sleep(Duration::from_millis(SERVER_WAIT_TIME_MS));
+
+        udp_testbench.check_next_sim_reply(&sim_reply);
+
+        // Now we check that the reply server can sent back replies to the client.
+        udp_testbench.stop();
+        server_thread.join().unwrap();
+    }
+
+    #[test]
+    fn test_udp_reply_server_old_replies_overwritten() {
+        let (mut udp_testbench, mut udp_server) =
+            UdpTestbench::new(true, None, 3).expect("could not create testbench");
+
+        let server_thread = std::thread::spawn(move || udp_server.run());
+
+        // The server only caches up to 3 replies.
+        let sim_reply = SimReply::new(SimCtrlReply::Pong);
+        for _ in 0..4 {
+            udp_testbench.send_reply(&sim_reply);
+        }
+        std::thread::sleep(Duration::from_millis(20));
+
+        udp_testbench.check_no_sim_reply_available();
+
+        // Connect by sending a ping.
+        udp_testbench
+            .send_request(&SimRequest::new(SimCtrlRequest::Ping))
+            .expect("sending request failed");
+        std::thread::sleep(Duration::from_millis(SERVER_WAIT_TIME_MS));
+
+        for _ in 0..3 {
+            udp_testbench.check_next_sim_reply(&sim_reply);
+        }
+        udp_testbench.check_no_sim_reply_available();
+        udp_testbench.stop();
+        server_thread.join().unwrap();
+    }
+}

satrs-shared/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.1.3] 2024-04-16
+
+Allow `spacepackets` range starting with v0.10 and v0.11.
+
 # [v0.1.2] 2024-02-17
 
 - Bumped `spacepackets` to v0.10.0 for `UnsignedEnum` trait change.

satrs-shared/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "satrs-shared"
 description = "Components shared by multiple sat-rs crates"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -18,7 +18,7 @@ default-features = false
 optional = true
 
 [dependencies.spacepackets]
-version = "0.10"
+version = ">0.9, <=0.11"
 default-features = false
 
 [features]

satrs/CHANGELOG.md

@@ -8,7 +8,91 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.2.0]
+# [v0.2.0-rc.2] 2024-04-17
+
+docs-rs hotfix
+
+# [v0.2.0-rc.1] 2024-04-17
+
+- `spacepackets` v0.11
+
+## Added
+
+- Added `params::WritableToBeBytes::to_vec`.
+- New `ComponentId` (`u64` typedef for now) which replaces former `TargetId` as a generic
+  way to identify components.
+- Various abstraction and objects for targeted requests. This includes mode request/reply
+  types for actions, HK and modes.
+- `VerificationReportingProvider::owner_id` method.
+- Introduced generic `EventMessage` which is generic over the event type and the additional
+  parameter type. This message also contains the sender ID which can be useful for debugging
+  or application layer / FDIR logic.
+- Stop signal handling for the TCP servers.
+- TCP server now uses `mio` crate to allow non-blocking operation. The server can now handle
+  multiple connections at once, and the context information about handled transfers is
+  passed via a callback which is inserted as a generic as well.
+
+## Changed
+
+- Renamed `ReceivesTcCore` to `PacketSenderRaw` to better show its primary purpose. It now contains
+  a `send_raw_tc` method which is not mutable anymore.
+- Renamed `TmPacketSourceCore` to `TmPacketSource`.
+- Renamed `EcssTmSenderCore` to `EcssTmSender`.
+- Renamed `StoreAddr` to `PoolAddr`.
+- Reanmed `StoreError` to `PoolError`.
+- TCP server generics order. The error generics come last now.
+- `encoding::ccsds::PacketIdValidator` renamed to `ValidatorU16Id`, which lives in the crate root.
+  It can be used for both CCSDS packet ID and CCSDS APID validation.
+- `EventManager::try_event_handling` not expects a mutable error handling closure instead of
+  returning the occured errors.
+- Renamed `EventManagerBase` to `EventReportCreator`
+- Renamed `VerificationReporterCore` to `VerificationReportCreator`.
+- Removed `VerificationReporterCore`. The high-level API exposed by `VerificationReporter` and
+  the low level API exposed by `VerificationReportCreator` should be sufficient for all use-cases.
+- Refactored `EventManager` to heavily use generics instead of trait objects.
+  - `SendEventProvider` -> `EventSendProvider`. `id` trait method renamed to `channel_id`.
+  - `ListenerTable` -> `ListenerMapProvider`
+  - `SenderTable` -> `SenderMapProvider`
+  - There is an `EventManagerWithMpsc` and a `EventManagerWithBoundedMpsc` helper type now.
+- Refactored ECSS TM sender abstractions to be generic over different message queue backends.
+- Refactored Verification Reporter abstractions and implementation to be generic over the sender
+  instead of using trait objects.
+- Renamed `WritableToBeBytes::raw_len` to `WritableToBeBytes::written_len` for consistency.
+- `PusServiceProvider` renamed to `PusServiceDistributor` to make the purpose of the object
+  more clear
+- `PusServiceProvider::handle_pus_tc_packet` renamed to `PusServiceDistributor::distribute_packet`.
+- `PusServiceDistibutor` and `CcsdsDistributor` now use generics instead of trait objects.
+  This makes accessing the concrete trait implementations more easy as well.
+- Major overhaul of the PUS handling module.
+- Replace `TargetId` by `ComponentId`.
+- Replace most usages of `ChannelId` by `ComponentId`. A dedicated channel ID has limited usage
+  due to the nature of typed channels in Rust.
+- `CheckTimer` renamed to `CountdownProvider`.
+- Renamed `TargetId` to `ComponentId`.
+- Replaced most `ChannelId` occurences with `ComponentId`. For typed channels, there is generally
+  no need for dedicated channel IDs.
+- Changed `params::WritableToBeBytes::raw_len` to `written_len` for consistency.
+- `EventReporter` caches component ID.
+- Renamed `PusService11SchedHandler` to `PusSchedServiceHandler`.
+- Fixed general naming of PUS handlers from `handle_one_tc` to `poll_and_handle_next_tc`.
+- Reworked verification module: The sender (`impl EcssTmSenderCore`)
+  now needs to be passed explicitely to the `VerificationReportingProvider` abstraction. This
+  allows easier sharing of the TM sender component.
+
+## Fixed
+
+- Update deprecated API for `PusScheduler::insert_wrapped_tc_cds_short`
+  and `PusScheduler::insert_wrapped_tc_cds_long`.
+- `EventReporter` uses interior mutability pattern to allow non-mutable API.
+
+## Removed
+
+- Remove `objects` module.
+- Removed CCSDS and PUS distributor modules. Their worth is questionable in an architecture
+  where routing traits are sufficient and the core logic to demultiplex and distribute packets
+  is simple enough to be application code.
+
+# [v0.2.0-rc.0] 2024-02-21
 
 ## Added
 
@@ -17,6 +101,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - New `VerificationReportingProvider` abstraction to avoid relying on a concrete verification
   reporting provider.
 
+## Changed
+
+- Verification reporter API timestamp arguments are not `Option`al anymore. Empty timestamps
+  can be passed by simply specifying the `&[]` empty slice argument.
+
 # [v0.1.1] 2024-02-12
 
 - Minor fixes for crate config `homepage` entries and links in documentation.

satrs/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "satrs"
-version = "0.1.1"
+version = "0.2.0-rc.2"
 edition = "2021"
-rust-version = "1.61"
+rust-version = "1.71.1"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "A framework to build software for remote systems"
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -17,12 +17,28 @@ delegate = ">0.7, <=0.10"
 paste = "1"
 smallvec = "1"
 crc = "3"
-satrs-shared = "0.1.2"
+
+[dependencies.satrs-shared]
+version = ">=0.1.3, <0.2"
 
 [dependencies.num_enum]
 version = ">0.5, <=0.7"
 default-features = false
 
+[dependencies.spacepackets]
+version = "0.11"
+default-features = false
+
+[dependencies.cobs]
+git = "https://github.com/robamu/cobs.rs.git"
+version = "0.2.3"
+branch = "all_features"
+default-features = false
+
+[dependencies.num-traits]
+version = "0.2"
+default-features = false
+
 [dependencies.dyn-clone]
 version = "1"
 optional = true
@@ -35,10 +51,6 @@ optional = true
 version = "0.7"
 optional = true
 
-[dependencies.num-traits]
-version = "0.2"
-default-features = false
-
 [dependencies.downcast-rs]
 version = "1.2"
 default-features = false
@@ -67,15 +79,10 @@ version = "0.5.4"
 features = ["all"]
 optional = true
 
-[dependencies.spacepackets]
-version = "0.10"
-default-features = false
-
-[dependencies.cobs]
-git = "https://github.com/robamu/cobs.rs.git"
-version = "0.2.3"
-branch = "all_features"
-default-features = false
+[dependencies.mio]
+version = "0.8"
+features = ["os-poll", "net"]
+optional = true
 
 [dev-dependencies]
 serde = "1"
@@ -100,7 +107,8 @@ std = [
     "spacepackets/std",
     "num_enum/std",
     "thiserror",
-    "socket2"
+    "socket2",
+    "mio"
 ]
 alloc = [
     "serde/alloc",
@@ -112,6 +120,8 @@ alloc = [
 serde = ["dep:serde", "spacepackets/serde", "satrs-shared/serde"]
 crossbeam = ["crossbeam-channel"]
 heapless = ["dep:heapless"]
+defmt = ["spacepackets/defmt"]
+test_util = []
 doc-images = []
 
 [package.metadata.docs.rs]

satrs/release-checklist.md

@@ -4,11 +4,11 @@ Checklist for new releases
 # Pre-Release
 
 1. Make sure any new modules are documented sufficiently enough and check docs with
-   `cargo +nightly doc --all-features --config 'rustdocflags=["--cfg", "doc_cfg"]' --open`.
+   `cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]' --open`.
 2. Bump version specifier in `Cargo.toml`.
 3. Update `CHANGELOG.md`: Convert `unreleased` section into version section with date and add new
    `unreleased` section.
-4. Run `cargo test --all-features`.
+4. Run `cargo test --all-features` or `cargo nextest r --all-features` and `cargo test --doc`.
 5. Run `cargo fmt` and `cargo clippy`. Check `cargo msrv` against MSRV in `Cargo.toml`.
 6. Wait for CI/CD results for EGit and Github. These also check cross-compilation for bare-metal
    targets.

satrs/src/action.rs

@@ -1,42 +1,68 @@
-use crate::{pool::StoreAddr, TargetId};
+use crate::{params::Params, pool::PoolAddr};
+
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
 
 pub type ActionId = u32;
 
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct ActionRequest {
+    pub action_id: ActionId,
+    pub variant: ActionRequestVariant,
+}
+
+impl ActionRequest {
+    pub fn new(action_id: ActionId, variant: ActionRequestVariant) -> Self {
+        Self { action_id, variant }
+    }
+}
+
 #[non_exhaustive]
 #[derive(Clone, Eq, PartialEq, Debug)]
-pub enum ActionRequest {
-    UnsignedIdAndStoreData {
-        action_id: ActionId,
-        data_addr: StoreAddr,
-    },
+pub enum ActionRequestVariant {
+    NoData,
+    StoreData(PoolAddr),
     #[cfg(feature = "alloc")]
-    UnsignedIdAndVecData {
-        action_id: ActionId,
-        data: alloc::vec::Vec<u8>,
-    },
-    #[cfg(feature = "alloc")]
-    StringIdAndVecData {
-        action_id: alloc::string::String,
-        data: alloc::vec::Vec<u8>,
-    },
-    #[cfg(feature = "alloc")]
-    StringIdAndStoreData {
-        action_id: alloc::string::String,
-        data: StoreAddr,
-    },
+    VecData(alloc::vec::Vec<u8>),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TargetedActionRequest {
-    target: TargetId,
-    action_request: ActionRequest,
+#[derive(Debug, PartialEq, Clone)]
+pub struct ActionReply {
+    pub action_id: ActionId,
+    pub variant: ActionReplyVariant,
 }
 
-impl TargetedActionRequest {
-    pub fn new(target: TargetId, action_request: ActionRequest) -> Self {
-        Self {
-            target,
-            action_request,
+/// A reply to an action request.
+#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq)]
+pub enum ActionReplyVariant {
+    CompletionFailed(Params),
+    StepFailed { step: u32, reason: Params },
+    Completed,
+}
+
+#[cfg(feature = "alloc")]
+pub mod alloc_mod {
+    use super::*;
+
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    pub struct ActionRequestStringId {
+        pub action_id: alloc::string::String,
+        pub variant: ActionRequestVariant,
+    }
+
+    impl ActionRequestStringId {
+        pub fn new(action_id: alloc::string::String, variant: ActionRequestVariant) -> Self {
+            Self { action_id, variant }
         }
     }
+
+    #[derive(Debug, PartialEq, Clone)]
+    pub struct ActionReplyStringId {
+        pub action_id: alloc::string::String,
+        pub variant: ActionReplyVariant,
     }
+}
+
+#[cfg(test)]
+mod tests {}

satrs/src/cfdp/dest.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use super::{
     filestore::{FilestoreError, VirtualFilestore},
     user::{CfdpUser, FileSegmentRecvdParams, MetadataReceivedParams},
-    CheckTimer, CheckTimerCreator, EntityType, LocalEntityConfig, PacketInfo, PacketTarget,
+    CheckTimerCreator, CountdownProvider, EntityType, LocalEntityConfig, PacketInfo, PacketTarget,
     RemoteEntityConfig, RemoteEntityConfigProvider, State, TimerContext, TransactionId,
     TransactionStep,
 };
@@ -54,7 +54,7 @@ struct TransferState {
     completion_disposition: CompletionDisposition,
     checksum: u32,
     current_check_count: u32,
-    current_check_timer: Option<Box<dyn CheckTimer>>,
+    current_check_timer: Option<Box<dyn CountdownProvider>>,
 }
 
 impl Default for TransferState {
@@ -799,9 +799,9 @@ mod tests {
     };
 
     use crate::cfdp::{
-        filestore::NativeFilestore, user::OwnedMetadataRecvdParams, CheckTimer, CheckTimerCreator,
-        DefaultFaultHandler, IndicationConfig, RemoteEntityConfig, StdRemoteEntityConfigProvider,
-        UserFaultHandler, CRC_32,
+        filestore::NativeFilestore, user::OwnedMetadataRecvdParams, CheckTimerCreator,
+        CountdownProvider, DefaultFaultHandler, IndicationConfig, RemoteEntityConfig,
+        StdRemoteEntityConfigProvider, UserFaultHandler, CRC_32,
     };
 
     use super::*;
@@ -1057,7 +1057,7 @@ mod tests {
         expired: Arc<AtomicBool>,
     }
 
-    impl CheckTimer for TestCheckTimer {
+    impl CountdownProvider for TestCheckTimer {
         fn has_expired(&self) -> bool {
             self.expired.load(core::sync::atomic::Ordering::Relaxed)
         }
@@ -1088,7 +1088,10 @@ mod tests {
     }
 
     impl CheckTimerCreator for TestCheckTimerCreator {
-        fn get_check_timer_provider(&self, timer_context: TimerContext) -> Box<dyn CheckTimer> {
+        fn get_check_timer_provider(
+            &self,
+            timer_context: TimerContext,
+        ) -> Box<dyn CountdownProvider> {
             match timer_context {
                 TimerContext::CheckLimit { .. } => {
                     Box::new(TestCheckTimer::new(self.check_limit_expired_flag.clone()))

satrs/src/cfdp/filestore.rs

@@ -7,7 +7,7 @@ use spacepackets::ByteConversionError;
 use std::error::Error;
 use std::path::Path;
 #[cfg(feature = "std")]
-pub use stdmod::*;
+pub use std_mod::*;
 
 pub const CRC_32: Crc<u32> = Crc::<u32>::new(&CRC_32_CKSUM);
 
@@ -148,12 +148,11 @@ pub trait VirtualFilestore {
 }
 
 #[cfg(feature = "std")]
-pub mod stdmod {
+pub mod std_mod {
     use super::*;
     use std::{
         fs::{self, File, OpenOptions},
         io::{BufReader, Read, Seek, SeekFrom, Write},
-        path::Path,
     };
 
     #[derive(Default)]

satrs/src/cfdp/mod.rs

@@ -17,6 +17,8 @@ use alloc::boxed::Box;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use crate::time::CountdownProvider;
+
 #[cfg(feature = "std")]
 pub mod dest;
 #[cfg(feature = "alloc")]
@@ -45,7 +47,15 @@ pub enum TimerContext {
     },
 }
 
-/// Generic abstraction for a check timer which is used by 3 mechanisms of the CFDP protocol.
+/// A generic trait which allows CFDP entities to create check timers which are required to
+/// implement special procedures in unacknowledged transmission mode, as specified in 4.6.3.2
+/// and 4.6.3.3.
+///
+/// This trait also allows the creation of different check timers depending on context and purpose
+/// of the timer, the runtime environment (e.g. standard clock timer vs. timer using a RTC) or
+/// other factors.
+///
+/// The countdown timer is used by 3 mechanisms of the CFDP protocol.
 ///
 /// ## 1. Check limit handling
 ///
@@ -74,22 +84,9 @@ pub enum TimerContext {
 /// The timer will be used to perform the Positive Acknowledgement Procedures as  specified in
 /// 4.7. 1of the CFDP standard. The expiration period will be provided by the Positive ACK timer
 /// interval of the remote entity configuration.
-pub trait CheckTimer: Debug {
-    fn has_expired(&self) -> bool;
-    fn reset(&mut self);
-}
-
-/// A generic trait which allows CFDP entities to create check timers which are required to
-/// implement special procedures in unacknowledged transmission mode, as specified in 4.6.3.2
-/// and 4.6.3.3. The [CheckTimer] documentation provides more information about the purpose of the
-/// check timer in the context of CFDP.
-///
-/// This trait also allows the creation of different check timers depending on context and purpose
-/// of the timer, the runtime environment (e.g. standard clock timer vs. timer using a RTC) or
-/// other factors.
 #[cfg(feature = "alloc")]
 pub trait CheckTimerCreator {
-    fn get_check_timer_provider(&self, timer_context: TimerContext) -> Box<dyn CheckTimer>;
+    fn get_check_timer_provider(&self, timer_context: TimerContext) -> Box<dyn CountdownProvider>;
 }
 
 /// Simple implementation of the [CheckTimerCreator] trait assuming a standard runtime.
@@ -112,7 +109,7 @@ impl StdCheckTimer {
 }
 
 #[cfg(feature = "std")]
-impl CheckTimer for StdCheckTimer {
+impl CountdownProvider for StdCheckTimer {
     fn has_expired(&self) -> bool {
         let elapsed_time = self.start_time.elapsed();
         if elapsed_time.as_secs() > self.expiry_time_seconds {

satrs/src/encoding/ccsds.rs

@@ -1,84 +1,52 @@
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-#[cfg(feature = "alloc")]
-use hashbrown::HashSet;
-use spacepackets::PacketId;
+use spacepackets::{CcsdsPacket, SpHeader};
 
-use crate::tmtc::ReceivesTcCore;
+use crate::{tmtc::PacketSenderRaw, ComponentId};
 
-pub trait PacketIdLookup {
-    fn validate(&self, packet_id: u16) -> bool;
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum SpValidity {
+    Valid,
+    /// The space packet can be assumed to have a valid format, but the packet should
+    /// be skipped.
+    Skip,
+    /// The space packet or space packet header has an invalid format, for example a CRC check
+    /// failed. In that case, the parser loses the packet synchronization and needs to check for
+    /// the start of a new space packet header start again. The space packet header
+    /// [spacepackets::PacketId] can be used as a synchronization marker to detect the start
+    /// of a possible valid packet again.
+    Invalid,
 }
 
-#[cfg(feature = "alloc")]
-impl PacketIdLookup for Vec<u16> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&packet_id)
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl PacketIdLookup for HashSet<u16> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&packet_id)
-    }
-}
-
-impl PacketIdLookup for [u16] {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.binary_search(&packet_id).is_ok()
-    }
-}
-
-impl PacketIdLookup for &[u16] {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.binary_search(&packet_id).is_ok()
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl PacketIdLookup for Vec<PacketId> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&PacketId::from(packet_id))
-    }
-}
-#[cfg(feature = "alloc")]
-impl PacketIdLookup for HashSet<PacketId> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&PacketId::from(packet_id))
-    }
-}
-
-impl PacketIdLookup for [PacketId] {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.binary_search(&PacketId::from(packet_id)).is_ok()
-    }
-}
-
-impl PacketIdLookup for &[PacketId] {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.binary_search(&PacketId::from(packet_id)).is_ok()
-    }
+/// Simple trait to allow user code to check the validity of a space packet.
+pub trait SpacePacketValidator {
+    fn validate(&self, sp_header: &SpHeader, raw_buf: &[u8]) -> SpValidity;
 }
 
 /// This function parses a given buffer for tightly packed CCSDS space packets. It uses the
-/// [PacketId] field of the CCSDS packets to detect the start of a CCSDS space packet and then
-/// uses the length field of the packet to extract CCSDS packets.
+/// [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.
 /// If broken tail packets are detected, they are moved to the front of the buffer, and the write
 /// index for future write operations will be written to the `next_write_idx` argument.
 ///
-/// The parser will write all packets which were decoded successfully to the given `tc_receiver`
-/// and return the number of packets found. If the [ReceivesTcCore::pass_tc] calls fails, the
+/// The parses will behave differently based on the [SpValidity] returned from the user provided
+/// [SpacePacketValidator]:
+///
+///  1. [SpValidity::Valid]: The parser will forward all packets to the given `packet_sender` and
+///     return the number of packets found.If the [PacketSenderRaw::send_packet] calls fails, the
 ///     error will be returned.
-pub fn parse_buffer_for_ccsds_space_packets<E>(
+///  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: &mut [u8],
-    packet_id_lookup: &(impl PacketIdLookup + ?Sized),
-    tc_receiver: &mut (impl ReceivesTcCore<Error = E> + ?Sized),
+    packet_validator: &(impl SpacePacketValidator + ?Sized),
+    sender_id: ComponentId,
+    packet_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
     next_write_idx: &mut usize,
-) -> Result<u32, E> {
+) -> Result<u32, SendError> {
     *next_write_idx = 0;
     let mut packets_found = 0;
     let mut current_idx = 0;
@@ -87,13 +55,14 @@ pub fn parse_buffer_for_ccsds_space_packets<E>(
         if current_idx + 7 >= buf.len() {
             break;
         }
-        let packet_id = u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap());
-        if packet_id_lookup.validate(packet_id) {
-            let length_field =
-                u16::from_be_bytes(buf[current_idx + 4..current_idx + 6].try_into().unwrap());
-            let packet_size = length_field + 7;
-            if (current_idx + packet_size as usize) <= buf_len {
-                tc_receiver.pass_tc(&buf[current_idx..current_idx + packet_size as usize])?;
+        let sp_header = SpHeader::from_be_bytes(&buf[current_idx..]).unwrap().0;
+        // let packet_id = u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap());
+        match packet_validator.validate(&sp_header, &buf[current_idx..]) {
+            SpValidity::Valid => {
+                let packet_size = sp_header.total_len();
+                if (current_idx + packet_size) <= buf_len {
+                    packet_sender
+                        .send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
                     packets_found += 1;
                 } else {
                     // Move packet to start of buffer if applicable.
@@ -102,11 +71,18 @@ pub fn parse_buffer_for_ccsds_space_packets<E>(
                         *next_write_idx = buf.len() - current_idx;
                     }
                 }
-            current_idx += packet_size as usize;
+                current_idx += packet_size;
                 continue;
             }
+            SpValidity::Skip => {
+                current_idx += sp_header.total_len();
+            }
+            // We might have lost sync. Try to find the start of a new space packet header.
+            SpValidity::Invalid => {
                 current_idx += 1;
             }
+        }
+    }
     Ok(packets_found)
 }
 
@@ -114,50 +90,75 @@ pub fn parse_buffer_for_ccsds_space_packets<E>(
 mod tests {
     use spacepackets::{
         ecss::{tc::PusTcCreator, WritablePusPacket},
-        PacketId, SpHeader,
+        CcsdsPacket, PacketId, SpHeader,
     };
 
-    use crate::encoding::tests::TcCacher;
+    use crate::{encoding::tests::TcCacher, ComponentId};
 
-    use super::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: u16 = 0x02;
     const TEST_APID_1: u16 = 0x10;
-    const TEST_PACKET_ID_0: PacketId = PacketId::const_tc(true, TEST_APID_0);
-    const TEST_PACKET_ID_1: PacketId = PacketId::const_tc(true, TEST_APID_1);
+    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);
+
+    #[derive(Default)]
+    struct SimpleVerificator {
+        pub enable_second_id: bool,
+    }
+
+    impl SimpleVerificator {
+        pub fn new_with_second_id() -> Self {
+            Self {
+                enable_second_id: true,
+            }
+        }
+    }
+
+    impl SpacePacketValidator for SimpleVerificator {
+        fn validate(&self, sp_header: &SpHeader, _raw_buf: &[u8]) -> super::SpValidity {
+            if sp_header.packet_id() == TEST_PACKET_ID_0
+                || (self.enable_second_id && sp_header.packet_id() == TEST_PACKET_ID_1)
+            {
+                return SpValidity::Valid;
+            }
+            SpValidity::Skip
+        }
+    }
 
     #[test]
     fn test_basic() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let sph = SpHeader::new_from_apid(TEST_APID_0);
+        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)
             .expect("writing packet failed");
-        let valid_packet_ids = [TEST_PACKET_ID_0];
-        let mut tc_cacher = TcCacher::default();
+        let tc_cacher = TcCacher::default();
         let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
             &mut buffer,
-            valid_packet_ids.as_slice(),
-            &mut tc_cacher,
+            &SimpleVerificator::default(),
+            PARSER_ID,
+            &tc_cacher,
             &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
         let parsed_packets = parse_result.unwrap();
         assert_eq!(parsed_packets, 1);
-        assert_eq!(tc_cacher.tc_queue.len(), 1);
-        assert_eq!(
-            tc_cacher.tc_queue.pop_front().unwrap(),
-            buffer[..packet_len]
-        );
+        let mut queue = tc_cacher.tc_queue.borrow_mut();
+        assert_eq!(queue.len(), 1);
+        let packet_with_sender = queue.pop_front().unwrap();
+        assert_eq!(packet_with_sender.packet, buffer[..packet_len]);
+        assert_eq!(packet_with_sender.sender_id, PARSER_ID);
     }
 
     #[test]
     fn test_multi_packet() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+        let sph = SpHeader::new_from_apid(TEST_APID_0);
+        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)
@@ -165,35 +166,37 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
-        let valid_packet_ids = [TEST_PACKET_ID_0];
-        let mut tc_cacher = TcCacher::default();
+        let tc_cacher = TcCacher::default();
         let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
             &mut buffer,
-            valid_packet_ids.as_slice(),
-            &mut tc_cacher,
+            &SimpleVerificator::default(),
+            PARSER_ID,
+            &tc_cacher,
             &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
         let parsed_packets = parse_result.unwrap();
         assert_eq!(parsed_packets, 2);
-        assert_eq!(tc_cacher.tc_queue.len(), 2);
+        let mut queue = tc_cacher.tc_queue.borrow_mut();
+        assert_eq!(queue.len(), 2);
+        let packet_with_addr = queue.pop_front().unwrap();
+        assert_eq!(packet_with_addr.packet, buffer[..packet_len_ping]);
+        assert_eq!(packet_with_addr.sender_id, PARSER_ID);
+        let packet_with_addr = queue.pop_front().unwrap();
+        assert_eq!(packet_with_addr.sender_id, PARSER_ID);
         assert_eq!(
-            tc_cacher.tc_queue.pop_front().unwrap(),
-            buffer[..packet_len_ping]
-        );
-        assert_eq!(
-            tc_cacher.tc_queue.pop_front().unwrap(),
+            packet_with_addr.packet,
             buffer[packet_len_ping..packet_len_ping + packet_len_action]
         );
     }
 
     #[test]
     fn test_multi_apid() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
-        sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+        let sph = SpHeader::new_from_apid(TEST_APID_0);
+        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, 8, 0, &[], true);
         let mut buffer: [u8; 32] = [0; 32];
         let packet_len_ping = ping_tc
             .write_to_bytes(&mut buffer)
@@ -201,35 +204,36 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
-        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
-        let mut tc_cacher = TcCacher::default();
+        let tc_cacher = TcCacher::default();
         let mut next_write_idx = 0;
+        let verificator = SimpleVerificator::new_with_second_id();
         let parse_result = parse_buffer_for_ccsds_space_packets(
             &mut buffer,
-            valid_packet_ids.as_slice(),
-            &mut tc_cacher,
+            &verificator,
+            PARSER_ID,
+            &tc_cacher,
             &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
         let parsed_packets = parse_result.unwrap();
         assert_eq!(parsed_packets, 2);
-        assert_eq!(tc_cacher.tc_queue.len(), 2);
+        let mut queue = tc_cacher.tc_queue.borrow_mut();
+        assert_eq!(queue.len(), 2);
+        let packet_with_addr = queue.pop_front().unwrap();
+        assert_eq!(packet_with_addr.packet, buffer[..packet_len_ping]);
+        let packet_with_addr = queue.pop_front().unwrap();
         assert_eq!(
-            tc_cacher.tc_queue.pop_front().unwrap(),
-            buffer[..packet_len_ping]
-        );
-        assert_eq!(
-            tc_cacher.tc_queue.pop_front().unwrap(),
+            packet_with_addr.packet,
             buffer[packet_len_ping..packet_len_ping + packet_len_action]
         );
     }
 
     #[test]
     fn test_split_packet_multi() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
-        sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+        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)
@@ -237,19 +241,22 @@ mod tests {
         let packet_len_action = action_tc
             .write_to_bytes(&mut buffer[packet_len_ping..])
             .expect("writing packet failed");
-        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
-        let mut tc_cacher = TcCacher::default();
+        let tc_cacher = TcCacher::default();
         let mut next_write_idx = 0;
+        let verificator = SimpleVerificator::new_with_second_id();
         let parse_result = parse_buffer_for_ccsds_space_packets(
             &mut buffer[..packet_len_ping + packet_len_action - 4],
-            valid_packet_ids.as_slice(),
-            &mut tc_cacher,
+            &verificator,
+            PARSER_ID,
+            &tc_cacher,
             &mut next_write_idx,
         );
         assert!(parse_result.is_ok());
         let parsed_packets = parse_result.unwrap();
         assert_eq!(parsed_packets, 1);
-        assert_eq!(tc_cacher.tc_queue.len(), 1);
+
+        let queue = tc_cacher.tc_queue.borrow();
+        assert_eq!(queue.len(), 1);
         // The broken packet was moved to the start, so the next write index should be after the
         // last segment missing 4 bytes.
         assert_eq!(next_write_idx, packet_len_action - 4);
@@ -257,25 +264,28 @@ mod tests {
 
     #[test]
     fn test_one_split_packet() {
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        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)
             .expect("writing packet failed");
-        let valid_packet_ids = [TEST_PACKET_ID_0, TEST_PACKET_ID_1];
-        let mut tc_cacher = TcCacher::default();
+        let tc_cacher = TcCacher::default();
+
+        let verificator = SimpleVerificator::new_with_second_id();
         let mut next_write_idx = 0;
         let parse_result = parse_buffer_for_ccsds_space_packets(
             &mut buffer[..packet_len_ping - 4],
-            valid_packet_ids.as_slice(),
-            &mut tc_cacher,
+            &verificator,
+            PARSER_ID,
+            &tc_cacher,
             &mut next_write_idx,
         );
         assert_eq!(next_write_idx, 0);
         assert!(parse_result.is_ok());
         let parsed_packets = parse_result.unwrap();
         assert_eq!(parsed_packets, 0);
-        assert_eq!(tc_cacher.tc_queue.len(), 0);
+        let queue = tc_cacher.tc_queue.borrow();
+        assert_eq!(queue.len(), 0);
     }
 }

satrs/src/encoding/cobs.rs

@@ -1,4 +1,4 @@
-use crate::tmtc::ReceivesTcCore;
+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
@@ -55,11 +55,12 @@ pub fn encode_packet_with_cobs(
 /// future write operations will be written to the `next_write_idx` argument.
 ///
 /// The parser will write all packets which were decoded successfully to the given `tc_receiver`.
-pub fn parse_buffer_for_cobs_encoded_packets<E>(
+pub fn parse_buffer_for_cobs_encoded_packets<SendError>(
     buf: &mut [u8],
-    tc_receiver: &mut dyn ReceivesTcCore<Error = E>,
+    sender_id: ComponentId,
+    packet_sender: &(impl PacketSenderRaw<Error = SendError> + ?Sized),
     next_write_idx: &mut usize,
-) -> Result<u32, E> {
+) -> Result<u32, SendError> {
     let mut start_index_packet = 0;
     let mut start_found = false;
     let mut last_byte = false;
@@ -78,8 +79,10 @@ pub fn parse_buffer_for_cobs_encoded_packets<E>(
                 let decode_result = decode_in_place(&mut buf[start_index_packet..i]);
                 if let Ok(packet_len) = decode_result {
                     packets_found += 1;
-                    tc_receiver
-                        .pass_tc(&buf[start_index_packet..start_index_packet + packet_len])?;
+                    packet_sender.send_packet(
+                        sender_id,
+                        &buf[start_index_packet..start_index_packet + packet_len],
+                    )?;
                 }
                 start_found = false;
             } else {
@@ -100,32 +103,39 @@ pub fn parse_buffer_for_cobs_encoded_packets<E>(
 pub(crate) mod tests {
     use cobs::encode;
 
-    use crate::encoding::tests::{encode_simple_packet, TcCacher, INVERTED_PACKET, SIMPLE_PACKET};
+    use crate::{
+        encoding::tests::{encode_simple_packet, TcCacher, INVERTED_PACKET, SIMPLE_PACKET},
+        ComponentId,
+    };
 
     use super::parse_buffer_for_cobs_encoded_packets;
 
+    const PARSER_ID: ComponentId = 0x05;
+
     #[test]
     fn test_parsing_simple_packet() {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut encoded_buf: [u8; 16] = [0; 16];
         let mut current_idx = 0;
         encode_simple_packet(&mut encoded_buf, &mut current_idx);
         let mut next_read_idx = 0;
         let packets = parse_buffer_for_cobs_encoded_packets(
             &mut encoded_buf[0..current_idx],
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_read_idx,
         )
         .unwrap();
         assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        let packet = &test_sender.tc_queue[0];
-        assert_eq!(packet, &SIMPLE_PACKET);
+        let queue = test_sender.tc_queue.borrow();
+        assert_eq!(queue.len(), 1);
+        let packet = &queue[0];
+        assert_eq!(packet.packet, &SIMPLE_PACKET);
     }
 
     #[test]
     fn test_parsing_consecutive_packets() {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut encoded_buf: [u8; 16] = [0; 16];
         let mut current_idx = 0;
         encode_simple_packet(&mut encoded_buf, &mut current_idx);
@@ -139,21 +149,23 @@ pub(crate) mod tests {
         let mut next_read_idx = 0;
         let packets = parse_buffer_for_cobs_encoded_packets(
             &mut encoded_buf[0..current_idx],
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_read_idx,
         )
         .unwrap();
         assert_eq!(packets, 2);
-        assert_eq!(test_sender.tc_queue.len(), 2);
-        let packet0 = &test_sender.tc_queue[0];
-        assert_eq!(packet0, &SIMPLE_PACKET);
-        let packet1 = &test_sender.tc_queue[1];
-        assert_eq!(packet1, &INVERTED_PACKET);
+        let queue = test_sender.tc_queue.borrow();
+        assert_eq!(queue.len(), 2);
+        let packet0 = &queue[0];
+        assert_eq!(packet0.packet, &SIMPLE_PACKET);
+        let packet1 = &queue[1];
+        assert_eq!(packet1.packet, &INVERTED_PACKET);
     }
 
     #[test]
     fn test_split_tail_packet_only() {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut encoded_buf: [u8; 16] = [0; 16];
         let mut current_idx = 0;
         encode_simple_packet(&mut encoded_buf, &mut current_idx);
@@ -161,17 +173,19 @@ pub(crate) mod tests {
         let packets = parse_buffer_for_cobs_encoded_packets(
             // Cut off the sentinel byte at the end.
             &mut encoded_buf[0..current_idx - 1],
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_read_idx,
         )
         .unwrap();
         assert_eq!(packets, 0);
-        assert_eq!(test_sender.tc_queue.len(), 0);
+        let queue = test_sender.tc_queue.borrow();
+        assert_eq!(queue.len(), 0);
         assert_eq!(next_read_idx, 0);
     }
 
     fn generic_test_split_packet(cut_off: usize) {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut encoded_buf: [u8; 16] = [0; 16];
         assert!(cut_off < INVERTED_PACKET.len() + 1);
         let mut current_idx = 0;
@@ -193,13 +207,15 @@ pub(crate) mod tests {
         let packets = parse_buffer_for_cobs_encoded_packets(
             // Cut off the sentinel byte at the end.
             &mut encoded_buf[0..current_idx - cut_off],
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_write_idx,
         )
         .unwrap();
         assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
+        let queue = test_sender.tc_queue.borrow();
+        assert_eq!(queue.len(), 1);
+        assert_eq!(&queue[0].packet, &SIMPLE_PACKET);
         assert_eq!(next_write_idx, next_expected_write_idx);
         assert_eq!(encoded_buf[..next_expected_write_idx], expected_at_start);
     }
@@ -221,7 +237,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_zero_at_end() {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut encoded_buf: [u8; 16] = [0; 16];
         let mut next_write_idx = 0;
         let mut current_idx = 0;
@@ -233,31 +249,35 @@ pub(crate) mod tests {
         let packets = parse_buffer_for_cobs_encoded_packets(
             // Cut off the sentinel byte at the end.
             &mut encoded_buf[0..current_idx],
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_write_idx,
         )
         .unwrap();
         assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
+        let queue = test_sender.tc_queue.borrow_mut();
+        assert_eq!(queue.len(), 1);
+        assert_eq!(&queue[0].packet, &SIMPLE_PACKET);
         assert_eq!(next_write_idx, 1);
         assert_eq!(encoded_buf[0], 0);
     }
 
     #[test]
     fn test_all_zeroes() {
-        let mut test_sender = TcCacher::default();
+        let test_sender = TcCacher::default();
         let mut all_zeroes: [u8; 5] = [0; 5];
         let mut next_write_idx = 0;
         let packets = parse_buffer_for_cobs_encoded_packets(
             // Cut off the sentinel byte at the end.
             &mut all_zeroes,
-            &mut test_sender,
+            PARSER_ID,
+            &test_sender,
             &mut next_write_idx,
         )
         .unwrap();
         assert_eq!(packets, 0);
-        assert!(test_sender.tc_queue.is_empty());
+        let queue = test_sender.tc_queue.borrow();
+        assert!(queue.is_empty());
         assert_eq!(next_write_idx, 0);
     }
 }

satrs/src/encoding/mod.rs

@@ -6,9 +6,14 @@ pub use crate::encoding::cobs::{encode_packet_with_cobs, parse_buffer_for_cobs_e
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use alloc::{collections::VecDeque, vec::Vec};
+    use core::cell::RefCell;
 
-    use crate::tmtc::ReceivesTcCore;
+    use alloc::collections::VecDeque;
+
+    use crate::{
+        tmtc::{PacketAsVec, PacketSenderRaw},
+        ComponentId,
+    };
 
     use super::cobs::encode_packet_with_cobs;
 
@@ -17,14 +22,15 @@ pub(crate) mod tests {
 
     #[derive(Default)]
     pub(crate) struct TcCacher {
-        pub(crate) tc_queue: VecDeque<Vec<u8>>,
+        pub(crate) tc_queue: RefCell<VecDeque<PacketAsVec>>,
     }
 
-    impl ReceivesTcCore for TcCacher {
+    impl PacketSenderRaw for TcCacher {
         type Error = ();
 
-        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-            self.tc_queue.push_back(tc_raw.to_vec());
+        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/events.rs

@@ -80,7 +80,7 @@ impl HasSeverity for SeverityHigh {
     const SEVERITY: Severity = Severity::HIGH;
 }
 
-pub trait GenericEvent: EcssEnumeration {
+pub trait GenericEvent: EcssEnumeration + Copy + Clone {
     type Raw;
     type GroupId;
     type UniqueId;

satrs/src/hal/mod.rs

@@ -1,4 +1,3 @@
 //! # Hardware Abstraction Layer module
 #[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std;

satrs/src/hal/std/tcp_cobs_server.rs

@@ -1,19 +1,25 @@
+use alloc::sync::Arc;
 use alloc::vec;
 use cobs::encode;
+use core::sync::atomic::AtomicBool;
+use core::time::Duration;
 use delegate::delegate;
+use mio::net::{TcpListener, TcpStream};
 use std::io::Write;
 use std::net::SocketAddr;
-use std::net::TcpListener;
-use std::net::TcpStream;
 use std::vec::Vec;
 
 use crate::encoding::parse_buffer_for_cobs_encoded_packets;
-use crate::tmtc::ReceivesTc;
-use crate::tmtc::TmPacketSource;
+use crate::tmtc::PacketSenderRaw;
+use crate::tmtc::PacketSource;
 
 use crate::hal::std::tcp_server::{
     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].
 #[derive(Default)]
@@ -23,14 +29,16 @@ impl<TmError, TcError: 'static> TcpTcParser<TmError, TcError> for CobsTcParser {
     fn handle_tc_parsing(
         &mut self,
         tc_buffer: &mut [u8],
-        tc_receiver: &mut (impl ReceivesTc<Error = TcError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        sender_id: ComponentId,
+        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],
-            tc_receiver.upcast_mut(),
+            sender_id,
+            tc_sender,
             next_write_idx,
         )
         .map_err(|e| TcpTmtcError::TcError(e))?;
@@ -57,8 +65,8 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for CobsTmSender {
     fn handle_tm_sending(
         &mut self,
         tm_buffer: &mut [u8],
-        tm_source: &mut (impl TmPacketSource<Error = TmError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        tm_source: &mut (impl PacketSource<Error = TmError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
         stream: &mut TcpStream,
     ) -> Result<bool, TcpTmtcError<TmError, TcError>> {
         let mut tm_was_sent = false;
@@ -96,7 +104,7 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for CobsTmSender {
 /// Telemetry will be encoded with the COBS  protocol using [cobs::encode] in addition to being
 /// wrapped with the sentinel value 0 as the packet delimiter as well before being sent back to
 /// the client. Please note that the server will send as much data as it can retrieve from the
-/// [TmPacketSource] in its current implementation.
+/// [PacketSource] in its current implementation.
 ///
 /// 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
@@ -107,24 +115,33 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for CobsTmSender {
 ///
 /// ## Example
 ///
-/// The [TCP integration tests](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-core/tests/tcp_servers.rs)
+/// 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 = TmError>,
+    TcSender: PacketSenderRaw<Error = SendError>,
+    HandledConnection: HandledConnectionHandler,
     TmError,
-    TcError: 'static,
-    TmSource: TmPacketSource<Error = TmError>,
-    TcReceiver: ReceivesTc<Error = TcError>,
+    SendError: 'static,
 > {
-    generic_server:
-        TcpTmtcGenericServer<TmError, TcError, TmSource, TcReceiver, CobsTmSender, CobsTcParser>,
+    pub generic_server: TcpTmtcGenericServer<
+        TmSource,
+        TcSender,
+        CobsTmSender,
+        CobsTcParser,
+        HandledConnection,
+        TmError,
+        SendError,
+    >,
 }
 
 impl<
+        TmSource: PacketSource<Error = TmError>,
+        TcReceiver: PacketSenderRaw<Error = TcError>,
+        HandledConnection: HandledConnectionHandler,
         TmError: 'static,
         TcError: 'static,
-        TmSource: TmPacketSource<Error = TmError>,
-        TcReceiver: ReceivesTc<Error = TcError>,
-    > TcpTmtcInCobsServer<TmError, TcError, TmSource, TcReceiver>
+    > 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).
@@ -140,6 +157,8 @@ impl<
         cfg: ServerConfig,
         tm_source: TmSource,
         tc_receiver: TcReceiver,
+        handled_connection: HandledConnection,
+        stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self {
             generic_server: TcpTmtcGenericServer::new(
@@ -148,6 +167,8 @@ impl<
                 CobsTmSender::new(cfg.tm_buffer_size),
                 tm_source,
                 tc_receiver,
+                handled_connection,
+                stop_signal,
             )?,
         })
     }
@@ -160,9 +181,10 @@ impl<
             /// useful if using the port number 0 for OS auto-assignment.
             pub fn local_addr(&self) -> std::io::Result<SocketAddr>;
 
-            /// Delegation to the [TcpTmtcGenericServer::handle_next_connection] call.
-            pub fn handle_next_connection(
+            /// Delegation to the [TcpTmtcGenericServer::handle_all_connections] call.
+            pub fn handle_all_connections(
                 &mut self,
+                poll_duration: Option<Duration>,
             ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>>;
         }
     }
@@ -177,21 +199,29 @@ mod tests {
     use std::{
         io::{Read, Write},
         net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream},
+        panic,
+        sync::mpsc,
         thread,
+        time::Instant,
     };
 
     use crate::{
         encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET},
         hal::std::tcp_server::{
-            tests::{SyncTcCacher, SyncTmSource},
-            ServerConfig,
+            tests::{ConnectionFinishedHandler, SyncTmSource},
+            ConnectionResult, ServerConfig,
         },
+        queue::GenericSendError,
+        tmtc::PacketAsVec,
+        ComponentId,
     };
     use alloc::sync::Arc;
     use cobs::encode;
 
     use super::TcpTmtcInCobsServer;
 
+    const TCP_SERVER_ID: ComponentId = 0x05;
+
     fn encode_simple_packet(encoded_buf: &mut [u8], current_idx: &mut usize) {
         encode_packet(&SIMPLE_PACKET, encoded_buf, current_idx)
     }
@@ -210,13 +240,22 @@ mod tests {
 
     fn generic_tmtc_server(
         addr: &SocketAddr,
-        tc_receiver: SyncTcCacher,
+        tc_sender: mpsc::Sender<PacketAsVec>,
         tm_source: SyncTmSource,
-    ) -> TcpTmtcInCobsServer<(), (), SyncTmSource, SyncTcCacher> {
+        stop_signal: Option<Arc<AtomicBool>>,
+    ) -> TcpTmtcInCobsServer<
+        SyncTmSource,
+        mpsc::Sender<PacketAsVec>,
+        ConnectionFinishedHandler,
+        (),
+        GenericSendError,
+    > {
         TcpTmtcInCobsServer::new(
-            ServerConfig::new(*addr, Duration::from_millis(2), 1024, 1024),
+            ServerConfig::new(TCP_SERVER_ID, *addr, Duration::from_millis(2), 1024, 1024),
             tm_source,
-            tc_receiver,
+            tc_sender,
+            ConnectionFinishedHandler::default(),
+            stop_signal,
         )
         .expect("TCP server generation failed")
     }
@@ -224,9 +263,10 @@ mod tests {
     #[test]
     fn test_server_basic_no_tm() {
         let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
-        let tc_receiver = SyncTcCacher::default();
+        let (tc_sender, tc_receiver) = mpsc::channel();
         let tm_source = SyncTmSource::default();
-        let mut tcp_server = generic_tmtc_server(&auto_port_addr, tc_receiver.clone(), tm_source);
+        let mut tcp_server =
+            generic_tmtc_server(&auto_port_addr, tc_sender.clone(), tm_source, None);
         let dest_addr = tcp_server
             .local_addr()
             .expect("retrieving dest addr failed");
@@ -234,13 +274,20 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_next_connection();
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
-            let conn_result = result.unwrap();
-            assert_eq!(conn_result.num_received_tcs, 1);
-            assert_eq!(conn_result.num_sent_tms, 0);
+            let result = result.unwrap();
+            assert_eq!(result, ConnectionResult::HandledConnections(1));
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_last_connection(0, 1);
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_no_connections_left();
             set_if_done.store(true, Ordering::Relaxed);
         });
         // Send TC to server now.
@@ -262,24 +309,20 @@ mod tests {
             panic!("connection was not handled properly");
         }
         // Check that the packet was received and decoded successfully.
-        let mut tc_queue = tc_receiver
-            .tc_queue
-            .lock()
-            .expect("locking tc queue failed");
-        assert_eq!(tc_queue.len(), 1);
-        assert_eq!(tc_queue.pop_front().unwrap(), &SIMPLE_PACKET);
-        drop(tc_queue);
+        let packet_with_sender = tc_receiver.recv().expect("receiving TC failed");
+        assert_eq!(packet_with_sender.packet, &SIMPLE_PACKET);
+        matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
     }
 
     #[test]
     fn test_server_basic_multi_tm_multi_tc() {
         let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
-        let tc_receiver = SyncTcCacher::default();
+        let (tc_sender, tc_receiver) = mpsc::channel();
         let mut tm_source = SyncTmSource::default();
         tm_source.add_tm(&INVERTED_PACKET);
         tm_source.add_tm(&SIMPLE_PACKET);
         let mut tcp_server =
-            generic_tmtc_server(&auto_port_addr, tc_receiver.clone(), tm_source.clone());
+            generic_tmtc_server(&auto_port_addr, tc_sender.clone(), tm_source.clone(), None);
         let dest_addr = tcp_server
             .local_addr()
             .expect("retrieving dest addr failed");
@@ -287,13 +330,20 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_next_connection();
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
-            let conn_result = result.unwrap();
-            assert_eq!(conn_result.num_received_tcs, 2, "Not enough TCs received");
-            assert_eq!(conn_result.num_sent_tms, 2, "Not enough TMs received");
+            let result = result.unwrap();
+            assert_eq!(result, ConnectionResult::HandledConnections(1));
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_last_connection(2, 2);
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_no_connections_left();
             set_if_done.store(true, Ordering::Relaxed);
         });
         // Send TC to server now.
@@ -367,13 +417,78 @@ mod tests {
             panic!("connection was not handled properly");
         }
         // Check that the packet was received and decoded successfully.
-        let mut tc_queue = tc_receiver
-            .tc_queue
-            .lock()
-            .expect("locking tc queue failed");
-        assert_eq!(tc_queue.len(), 2);
-        assert_eq!(tc_queue.pop_front().unwrap(), &SIMPLE_PACKET);
-        assert_eq!(tc_queue.pop_front().unwrap(), &INVERTED_PACKET);
-        drop(tc_queue);
+        let packet_with_sender = tc_receiver.recv().expect("receiving TC failed");
+        let packet = &packet_with_sender.packet;
+        assert_eq!(packet, &SIMPLE_PACKET);
+        let packet_with_sender = tc_receiver.recv().expect("receiving TC failed");
+        let packet = &packet_with_sender.packet;
+        assert_eq!(packet, &INVERTED_PACKET);
+        matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
+    }
+
+    #[test]
+    fn test_server_accept_timeout() {
+        let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
+        let (tc_sender, _tc_receiver) = mpsc::channel();
+        let tm_source = SyncTmSource::default();
+        let mut tcp_server =
+            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");
+            }
+        });
+        thread_jh.join().expect("thread join failed");
+    }
+
+    #[test]
+    fn test_server_stop_signal() {
+        let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
+        let (tc_sender, _tc_receiver) = mpsc::channel();
+        let tm_source = SyncTmSource::default();
+        let stop_signal = Arc::new(AtomicBool::new(false));
+        let mut tcp_server = generic_tmtc_server(
+            &auto_port_addr,
+            tc_sender.clone(),
+            tm_source,
+            Some(stop_signal.clone()),
+        );
+        let dest_addr = tcp_server
+            .local_addr()
+            .expect("retrieving dest addr failed");
+        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");
+            }
+        });
+        // We connect but do not do anything.
+        let _stream = TcpStream::connect(dest_addr).expect("connecting to TCP server failed");
+        stop_signal.store(true, Ordering::Relaxed);
+        // No need to drop the connection, the stop signal should take take of everything.
+        thread_jh.join().expect("thread join failed");
     }
 }

satrs/src/hal/std/tcp_server.rs

@@ -1,21 +1,25 @@
 //! Generic TCP TMTC servers with different TMTC format flavours.
+use alloc::sync::Arc;
 use alloc::vec;
 use alloc::vec::Vec;
+use core::sync::atomic::AtomicBool;
 use core::time::Duration;
+use mio::net::{TcpListener, TcpStream};
+use mio::{Events, Interest, Poll, Token};
 use socket2::{Domain, Socket, Type};
-use std::io::Read;
-use std::net::TcpListener;
-use std::net::{SocketAddr, TcpStream};
+use std::io::{self, Read};
+use std::net::SocketAddr;
+// use std::net::TcpListener;
+// use std::net::{SocketAddr, TcpStream};
 use std::thread;
 
-use crate::tmtc::{ReceivesTc, TmPacketSource};
+use crate::tmtc::{PacketSenderRaw, PacketSource};
+use crate::ComponentId;
 use thiserror::Error;
 
 // Re-export the TMTC in COBS server.
 pub use crate::hal::std::tcp_cobs_server::{CobsTcParser, CobsTmSender, TcpTmtcInCobsServer};
-pub use crate::hal::std::tcp_spacepackets_server::{
-    SpacepacketsTcParser, SpacepacketsTmSender, TcpSpacepacketsServer,
-};
+pub use crate::hal::std::tcp_spacepackets_server::{SpacepacketsTmSender, TcpSpacepacketsServer};
 
 /// Configuration struct for the generic TCP TMTC server
 ///
@@ -25,7 +29,7 @@ pub use crate::hal::std::tcp_spacepackets_server::{
 /// * `inner_loop_delay` - If a client connects for a longer period, but no TC is received or
 ///     no TM needs to be sent, the TCP server will delay for the specified amount of time
 ///     to reduce CPU load.
-/// * `tm_buffer_size` - Size of the TM buffer used to read TM from the [TmPacketSource] and
+/// * `tm_buffer_size` - Size of the TM buffer used to read TM from the [PacketSource] and
 ///     encoding of that data. This buffer should at large enough to hold the maximum expected
 ///     TM size read from the packet source.
 /// * `tc_buffer_size` - Size of the TC buffer used to read encoded telecommands sent from
@@ -41,6 +45,7 @@ pub use crate::hal::std::tcp_spacepackets_server::{
 ///     default.
 #[derive(Debug, Copy, Clone)]
 pub struct ServerConfig {
+    pub id: ComponentId,
     pub addr: SocketAddr,
     pub inner_loop_delay: Duration,
     pub tm_buffer_size: usize,
@@ -51,12 +56,14 @@ pub struct ServerConfig {
 
 impl ServerConfig {
     pub fn new(
+        id: ComponentId,
         addr: SocketAddr,
         inner_loop_delay: Duration,
         tm_buffer_size: usize,
         tc_buffer_size: usize,
     ) -> Self {
         Self {
+            id,
             addr,
             inner_loop_delay,
             tm_buffer_size,
@@ -79,37 +86,62 @@ pub enum TcpTmtcError<TmError, TcError> {
 
 /// Result of one connection attempt. Contains the client address if a connection was established,
 /// in addition to the number of telecommands and telemetry packets exchanged.
-#[derive(Debug, Default)]
-pub struct ConnectionResult {
-    pub addr: Option<SocketAddr>,
+#[derive(Debug, PartialEq, Eq)]
+pub enum ConnectionResult {
+    AcceptTimeout,
+    HandledConnections(u32),
+}
+
+#[derive(Debug)]
+pub struct HandledConnectionInfo {
+    pub addr: SocketAddr,
     pub num_received_tcs: u32,
     pub num_sent_tms: u32,
+    /// The generic TCP server can be stopped using an external signal. If this happened, this
+    /// boolean will be set to true.
+    pub stopped_by_signal: bool,
+}
+
+impl HandledConnectionInfo {
+    pub fn new(addr: SocketAddr) -> Self {
+        Self {
+            addr,
+            num_received_tcs: 0,
+            num_sent_tms: 0,
+            stopped_by_signal: false,
+        }
+    }
+}
+
+pub trait HandledConnectionHandler {
+    fn handled_connection(&mut self, info: HandledConnectionInfo);
 }
 
 /// Generic parser abstraction for an object which can parse for telecommands given a raw
-/// bytestream received from a TCP socket and send them to a generic [ReceivesTc] telecommand
-/// receiver. This allows different encoding schemes for telecommands.
-pub trait TcpTcParser<TmError, TcError> {
+/// 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],
-        tc_receiver: &mut (impl ReceivesTc<Error = TcError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        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, TcError>>;
+    ) -> Result<(), TcpTmtcError<TmError, SendError>>;
 }
 
 /// Generic sender abstraction for an object which can pull telemetry from a given TM source
-/// using a [TmPacketSource] and then send them back to a client using a given [TcpStream].
+/// 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<TmError, TcError> {
     fn handle_tm_sending(
         &mut self,
         tm_buffer: &mut [u8],
-        tm_source: &mut (impl TmPacketSource<Error = TmError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        tm_source: &mut (impl PacketSource<Error = TmError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
         stream: &mut TcpStream,
     ) -> Result<bool, TcpTmtcError<TmError, TcError>>;
 }
@@ -121,9 +153,9 @@ pub trait TcpTmSender<TmError, TcError> {
 /// 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 sent to the [ReceivesTc] telecommand receiver.
+/// 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. [TmPacketSource] as a generic TM source used by the [TcpTmSender].
+/// 4. [PacketSource] as a generic TM source used by the [TcpTmSender].
 ///
 /// It is possible to specify custom abstractions to build a dedicated TCP TMTC server without
 /// having to re-implement common logic.
@@ -131,32 +163,49 @@ pub trait TcpTmSender<TmError, TcError> {
 /// Currently, this framework offers the following concrete implementations:
 ///
 /// 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 = TmError>,
+    TcSender: PacketSenderRaw<Error = TcSendError>,
+    TmSender: TcpTmSender<TmError, TcSendError>,
+    TcParser: TcpTcParser<TmError, TcSendError>,
+    HandledConnection: HandledConnectionHandler,
     TmError,
-    TcError,
-    TmSource: TmPacketSource<Error = TmError>,
-    TcReceiver: ReceivesTc<Error = TcError>,
-    TmSender: TcpTmSender<TmError, TcError>,
-    TcParser: TcpTcParser<TmError, TcError>,
+    TcSendError,
 > {
+    pub id: ComponentId,
+    pub finished_handler: HandledConnection,
     pub(crate) listener: TcpListener,
     pub(crate) inner_loop_delay: Duration,
     pub(crate) tm_source: TmSource,
     pub(crate) tm_buffer: Vec<u8>,
-    pub(crate) tc_receiver: TcReceiver,
+    pub(crate) tc_sender: TcSender,
     pub(crate) tc_buffer: Vec<u8>,
-    tc_handler: TcParser,
-    tm_handler: TmSender,
+    poll: Poll,
+    events: Events,
+    pub tc_handler: TcParser,
+    pub tm_handler: TmSender,
+    stop_signal: Option<Arc<AtomicBool>>,
 }
 
 impl<
+        TmSource: PacketSource<Error = TmError>,
+        TcSender: PacketSenderRaw<Error = TcSendError>,
+        TmSender: TcpTmSender<TmError, TcSendError>,
+        TcParser: TcpTcParser<TmError, TcSendError>,
+        HandledConnection: HandledConnectionHandler,
         TmError: 'static,
-        TcError: 'static,
-        TmSource: TmPacketSource<Error = TmError>,
-        TcReceiver: ReceivesTc<Error = TcError>,
-        TmSender: TcpTmSender<TmError, TcError>,
-        TcParser: TcpTcParser<TmError, TcError>,
-    > TcpTmtcGenericServer<TmError, TcError, TmSource, TcReceiver, TmSender, TcParser>
+        TcSendError: 'static,
+    >
+    TcpTmtcGenericServer<
+        TmSource,
+        TcSender,
+        TmSender,
+        TcParser,
+        HandledConnection,
+        TmError,
+        TcSendError,
+    >
 {
     /// Create a new generic TMTC server instance.
     ///
@@ -168,32 +217,55 @@ impl<
     /// * `tm_sender` - Sends back telemetry to the client using the specified TM source.
     /// * `tm_source` - Generic TM source used by the server to pull telemetry packets which are
     ///     then sent back to the client.
-    /// * `tc_receiver` - Any received telecommand which was decoded successfully will be forwarded
-    ///     to this TC receiver.
+    /// * `tc_sender` - Any received telecommand which was decoded successfully will be forwarded
+    ///     using this TC sender.
+    /// * `stop_signal` - Can be used to stop the server even if a connection is ongoing.
     pub fn new(
         cfg: ServerConfig,
         tc_parser: TcParser,
         tm_sender: TmSender,
         tm_source: TmSource,
-        tc_receiver: TcReceiver,
+        tc_receiver: TcSender,
+        finished_handler: HandledConnection,
+        stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
         // Create a TCP listener bound to two addresses.
         let socket = Socket::new(Domain::IPV4, Type::STREAM, None)?;
+
         socket.set_reuse_address(cfg.reuse_addr)?;
         #[cfg(unix)]
         socket.set_reuse_port(cfg.reuse_port)?;
+        // MIO does not do this for us. We want the accept calls to be non-blocking.
+        socket.set_nonblocking(true)?;
         let addr = (cfg.addr).into();
         socket.bind(&addr)?;
         socket.listen(128)?;
+
+        // Create a poll instance.
+        let poll = Poll::new()?;
+        // Create storage for events.
+        let events = Events::with_capacity(10);
+        let listener: std::net::TcpListener = socket.into();
+        let mut mio_listener = TcpListener::from_std(listener);
+
+        // Start listening for incoming connections.
+        poll.registry()
+            .register(&mut mio_listener, Token(0), Interest::READABLE)?;
+
         Ok(Self {
+            id: cfg.id,
             tc_handler: tc_parser,
             tm_handler: tm_sender,
-            listener: socket.into(),
+            poll,
+            events,
+            listener: mio_listener,
             inner_loop_delay: cfg.inner_loop_delay,
             tm_source,
             tm_buffer: vec![0; cfg.tm_buffer_size],
-            tc_receiver,
+            tc_sender: tc_receiver,
             tc_buffer: vec![0; cfg.tc_buffer_size],
+            stop_signal,
+            finished_handler,
         })
     }
 
@@ -221,15 +293,52 @@ impl<
     /// The server will delay for a user-specified period if the client connects to the server
     /// for prolonged periods and there is no traffic for the server. This is the case if the
     /// client does not send any telecommands and no telemetry needs to be sent back to the client.
-    pub fn handle_next_connection(
+    pub fn handle_all_connections(
         &mut self,
-    ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>> {
-        let mut connection_result = ConnectionResult::default();
+        poll_timeout: Option<Duration>,
+    ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcSendError>> {
+        let mut handled_connections = 0;
+        // Poll Mio for events.
+        self.poll.poll(&mut self.events, poll_timeout)?;
+        let mut acceptable_connection = false;
+        // Process each event.
+        for event in self.events.iter() {
+            if event.token() == Token(0) {
+                acceptable_connection = true;
+            } else {
+                // Should never happen..
+                panic!("unexpected TCP event token");
+            }
+        }
+        // I'd love to do this in the loop above, but there are issues with multiple borrows.
+        if acceptable_connection {
+            // There might be mutliple connections available. Accept until all of them have
+            // been handled.
+            loop {
+                match self.listener.accept() {
+                    Ok((stream, addr)) => {
+                        self.handle_accepted_connection(stream, addr)?;
+                        handled_connections += 1;
+                    }
+                    Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => break,
+                    Err(err) => return Err(TcpTmtcError::Io(err)),
+                }
+            }
+        }
+        if handled_connections > 0 {
+            return Ok(ConnectionResult::HandledConnections(handled_connections));
+        }
+        Ok(ConnectionResult::AcceptTimeout)
+    }
+
+    fn handle_accepted_connection(
+        &mut self,
+        mut stream: TcpStream,
+        addr: SocketAddr,
+    ) -> Result<(), TcpTmtcError<TmError, TcSendError>> {
         let mut current_write_idx;
         let mut next_write_idx = 0;
-        let (mut stream, addr) = self.listener.accept()?;
-        stream.set_nonblocking(true)?;
-        connection_result.addr = Some(addr);
+        let mut connection_result = HandledConnectionInfo::new(addr);
         current_write_idx = next_write_idx;
         loop {
             let read_result = stream.read(&mut self.tc_buffer[current_write_idx..]);
@@ -240,7 +349,8 @@ impl<
                     if current_write_idx > 0 {
                         self.tc_handler.handle_tc_parsing(
                             &mut self.tc_buffer,
-                            &mut self.tc_receiver,
+                            self.id,
+                            &self.tc_sender,
                             &mut connection_result,
                             current_write_idx,
                             &mut next_write_idx,
@@ -254,7 +364,8 @@ impl<
                     if current_write_idx == self.tc_buffer.capacity() {
                         self.tc_handler.handle_tc_parsing(
                             &mut self.tc_buffer,
-                            &mut self.tc_receiver,
+                            self.id,
+                            &self.tc_sender,
                             &mut connection_result,
                             current_write_idx,
                             &mut next_write_idx,
@@ -268,7 +379,8 @@ impl<
                     std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut => {
                         self.tc_handler.handle_tc_parsing(
                             &mut self.tc_buffer,
-                            &mut self.tc_receiver,
+                            self.id,
+                            &self.tc_sender,
                             &mut connection_result,
                             current_write_idx,
                             &mut next_write_idx,
@@ -284,6 +396,18 @@ impl<
                             // No TC read, no TM was sent, but the client has not disconnected.
                             // Perform an inner delay to avoid burning CPU time.
                             thread::sleep(self.inner_loop_delay);
+                            // Optional stop signal handling.
+                            if self.stop_signal.is_some()
+                                && self
+                                    .stop_signal
+                                    .as_ref()
+                                    .unwrap()
+                                    .load(std::sync::atomic::Ordering::Relaxed)
+                            {
+                                connection_result.stopped_by_signal = true;
+                                self.finished_handler.handled_connection(connection_result);
+                                return Ok(());
+                            }
                         }
                     }
                     _ => {
@@ -298,7 +422,8 @@ impl<
             &mut connection_result,
             &mut stream,
         )?;
-        Ok(connection_result)
+        self.finished_handler.handled_connection(connection_result);
+        Ok(())
     }
 }
 
@@ -308,21 +433,9 @@ pub(crate) mod tests {
 
     use alloc::{collections::VecDeque, sync::Arc, vec::Vec};
 
-    use crate::tmtc::{ReceivesTcCore, TmPacketSourceCore};
+    use crate::tmtc::PacketSource;
 
-    #[derive(Default, Clone)]
-    pub(crate) struct SyncTcCacher {
-        pub(crate) tc_queue: Arc<Mutex<VecDeque<Vec<u8>>>>,
-    }
-    impl ReceivesTcCore for SyncTcCacher {
-        type Error = ();
-
-        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-            let mut tc_queue = self.tc_queue.lock().expect("tc forwarder failed");
-            tc_queue.push_back(tc_raw.to_vec());
-            Ok(())
-        }
-    }
+    use super::*;
 
     #[derive(Default, Clone)]
     pub(crate) struct SyncTmSource {
@@ -336,7 +449,7 @@ pub(crate) mod tests {
         }
     }
 
-    impl TmPacketSourceCore for SyncTmSource {
+    impl PacketSource for SyncTmSource {
         type Error = ();
 
         fn retrieve_packet(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error> {
@@ -356,4 +469,30 @@ pub(crate) mod tests {
             Ok(0)
         }
     }
+
+    #[derive(Default)]
+    pub struct ConnectionFinishedHandler {
+        connection_info: VecDeque<HandledConnectionInfo>,
+    }
+
+    impl HandledConnectionHandler for ConnectionFinishedHandler {
+        fn handled_connection(&mut self, info: HandledConnectionInfo) {
+            self.connection_info.push_back(info);
+        }
+    }
+
+    impl ConnectionFinishedHandler {
+        pub fn check_last_connection(&mut self, num_tms: u32, num_tcs: u32) {
+            let last_conn_result = self
+                .connection_info
+                .pop_back()
+                .expect("no connection info available");
+            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) {
+            assert!(self.connection_info.is_empty());
+        }
+    }
 }

satrs/src/hal/std/tcp_spacepackets_server.rs

@@ -1,45 +1,36 @@
+use alloc::sync::Arc;
+use core::{sync::atomic::AtomicBool, time::Duration};
 use delegate::delegate;
-use std::{
-    io::Write,
-    net::{SocketAddr, TcpListener, TcpStream},
-};
-
-use alloc::boxed::Box;
+use mio::net::{TcpListener, TcpStream};
+use std::{io::Write, net::SocketAddr};
 
 use crate::{
-    encoding::{ccsds::PacketIdLookup, parse_buffer_for_ccsds_space_packets},
-    tmtc::{ReceivesTc, TmPacketSource},
+    encoding::{ccsds::SpacePacketValidator, parse_buffer_for_ccsds_space_packets},
+    tmtc::{PacketSenderRaw, PacketSource},
+    ComponentId,
 };
 
 use super::tcp_server::{
-    ConnectionResult, ServerConfig, TcpTcParser, TcpTmSender, TcpTmtcError, TcpTmtcGenericServer,
+    ConnectionResult, HandledConnectionHandler, HandledConnectionInfo, ServerConfig, TcpTcParser,
+    TcpTmSender, TcpTmtcError, TcpTmtcGenericServer,
 };
 
-/// Concrete [TcpTcParser] implementation for the [TcpSpacepacketsServer].
-pub struct SpacepacketsTcParser {
-    packet_id_lookup: Box<dyn PacketIdLookup + Send>,
-}
-
-impl SpacepacketsTcParser {
-    pub fn new(packet_id_lookup: Box<dyn PacketIdLookup + Send>) -> Self {
-        Self { packet_id_lookup }
-    }
-}
-
-impl<TmError, TcError: 'static> TcpTcParser<TmError, TcError> for SpacepacketsTcParser {
+impl<T: SpacePacketValidator, TmError, TcError: 'static> TcpTcParser<TmError, TcError> for T {
     fn handle_tc_parsing(
         &mut self,
         tc_buffer: &mut [u8],
-        tc_receiver: &mut (impl ReceivesTc<Error = TcError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        sender_id: ComponentId,
+        tc_sender: &(impl PacketSenderRaw<Error = TcError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
         current_write_idx: usize,
         next_write_idx: &mut usize,
     ) -> Result<(), TcpTmtcError<TmError, TcError>> {
         // Reader vec full, need to parse for packets.
         conn_result.num_received_tcs += parse_buffer_for_ccsds_space_packets(
             &mut tc_buffer[..current_write_idx],
-            self.packet_id_lookup.as_ref(),
-            tc_receiver.upcast_mut(),
+            self,
+            sender_id,
+            tc_sender,
             next_write_idx,
         )
         .map_err(|e| TcpTmtcError::TcError(e))?;
@@ -55,8 +46,8 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for SpacepacketsTmSender {
     fn handle_tm_sending(
         &mut self,
         tm_buffer: &mut [u8],
-        tm_source: &mut (impl TmPacketSource<Error = TmError> + ?Sized),
-        conn_result: &mut ConnectionResult,
+        tm_source: &mut (impl PacketSource<Error = TmError> + ?Sized),
+        conn_result: &mut HandledConnectionInfo,
         stream: &mut TcpStream,
     ) -> Result<bool, TcpTmtcError<TmError, TcError>> {
         let mut tm_was_sent = false;
@@ -83,35 +74,41 @@ impl<TmError, TcError> TcpTmSender<TmError, TcError> for SpacepacketsTmSender {
 ///
 /// This serves only works if
 /// [CCSDS 133.0-B-2 space packets](https://public.ccsds.org/Pubs/133x0b2e1.pdf) are the only
-/// packet type being exchanged. It uses the CCSDS [spacepackets::PacketId] as the packet delimiter
-/// and start marker when parsing for packets. The user specifies a set of expected
-/// [spacepackets::PacketId]s as part of the server configuration for that purpose.
+/// packet type being exchanged. It uses the CCSDS space packet header [spacepackets::SpHeader] and
+/// a user specified [SpacePacketValidator] to determine the space packets relevant for further
+/// processing.
 ///
 /// ## Example
-/// The [TCP server integration tests](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-core/tests/tcp_servers.rs)
+///
+/// The [TCP server integration tests](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs/tests/tcp_servers.rs)
 /// also serves as the example application for this module.
 pub struct TcpSpacepacketsServer<
+    TmSource: PacketSource<Error = TmError>,
+    TcSender: PacketSenderRaw<Error = SendError>,
+    Validator: SpacePacketValidator,
+    HandledConnection: HandledConnectionHandler,
     TmError,
-    TcError: 'static,
-    TmSource: TmPacketSource<Error = TmError>,
-    TcReceiver: ReceivesTc<Error = TcError>,
+    SendError: 'static,
 > {
-    generic_server: TcpTmtcGenericServer<
-        TmError,
-        TcError,
+    pub generic_server: TcpTmtcGenericServer<
         TmSource,
-        TcReceiver,
+        TcSender,
         SpacepacketsTmSender,
-        SpacepacketsTcParser,
+        Validator,
+        HandledConnection,
+        TmError,
+        SendError,
     >,
 }
 
 impl<
+        TmSource: PacketSource<Error = TmError>,
+        TcSender: PacketSenderRaw<Error = TcError>,
+        Validator: SpacePacketValidator,
+        HandledConnection: HandledConnectionHandler,
         TmError: 'static,
         TcError: 'static,
-        TmSource: TmPacketSource<Error = TmError>,
-        TcReceiver: ReceivesTc<Error = TcError>,
-    > TcpSpacepacketsServer<TmError, TcError, TmSource, TcReceiver>
+    > TcpSpacepacketsServer<TmSource, TcSender, Validator, HandledConnection, TmError, TcError>
 {
     ///
     /// ## Parameter
@@ -119,23 +116,31 @@ impl<
     /// * `cfg` - Configuration of the server.
     /// * `tm_source` - Generic TM source used by the server to pull telemetry packets which are
     ///     then sent back to the client.
-    /// * `tc_receiver` - Any received telecommands which were decoded successfully will be
-    ///     forwarded to this TC receiver.
-    /// * `packet_id_lookup` - This lookup table contains the relevant packets IDs for packet
-    ///     parsing. This mechanism is used to have a start marker for finding CCSDS packets.
+    /// * `tc_sender` - Any received telecommands which were decoded successfully will be
+    ///     forwarded using this [PacketSenderRaw].
+    /// * `validator` - Used to determine the space packets relevant for further processing and
+    ///    to detect broken space packets.
+    /// * `handled_connection_hook` - Called to notify the user about a succesfully handled
+    ///    connection.
+    /// * `stop_signal` - Can be used to shut down the TCP server even for longer running
+    ///    connections.
     pub fn new(
         cfg: ServerConfig,
         tm_source: TmSource,
-        tc_receiver: TcReceiver,
-        packet_id_lookup: Box<dyn PacketIdLookup + Send>,
+        tc_sender: TcSender,
+        validator: Validator,
+        handled_connection_hook: HandledConnection,
+        stop_signal: Option<Arc<AtomicBool>>,
     ) -> Result<Self, std::io::Error> {
         Ok(Self {
             generic_server: TcpTmtcGenericServer::new(
                 cfg,
-                SpacepacketsTcParser::new(packet_id_lookup),
+                validator,
                 SpacepacketsTmSender::default(),
                 tm_source,
-                tc_receiver,
+                tc_sender,
+                handled_connection_hook,
+                stop_signal,
             )?,
         })
     }
@@ -148,9 +153,10 @@ impl<
             /// useful if using the port number 0 for OS auto-assignment.
             pub fn local_addr(&self) -> std::io::Result<SocketAddr>;
 
-            /// Delegation to the [TcpTmtcGenericServer::handle_next_connection] call.
-            pub fn handle_next_connection(
+            /// Delegation to the [TcpTmtcGenericServer::handle_all_connections] call.
+            pub fn handle_all_connections(
                 &mut self,
+                poll_timeout: Option<Duration>
             ) -> Result<ConnectionResult, TcpTmtcError<TmError, TcError>>;
         }
     }
@@ -167,39 +173,70 @@ mod tests {
     use std::{
         io::{Read, Write},
         net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream},
+        sync::mpsc,
         thread,
     };
 
-    use alloc::{boxed::Box, sync::Arc};
+    use alloc::sync::Arc;
     use hashbrown::HashSet;
     use spacepackets::{
         ecss::{tc::PusTcCreator, WritablePusPacket},
-        PacketId, SpHeader,
+        CcsdsPacket, PacketId, SpHeader,
     };
 
-    use crate::hal::std::tcp_server::{
-        tests::{SyncTcCacher, SyncTmSource},
-        ServerConfig,
+    use crate::{
+        encoding::ccsds::{SpValidity, SpacePacketValidator},
+        hal::std::tcp_server::{
+            tests::{ConnectionFinishedHandler, SyncTmSource},
+            ConnectionResult, ServerConfig,
+        },
+        queue::GenericSendError,
+        tmtc::PacketAsVec,
+        ComponentId,
     };
 
     use super::TcpSpacepacketsServer;
 
+    const TCP_SERVER_ID: ComponentId = 0x05;
     const TEST_APID_0: u16 = 0x02;
-    const TEST_PACKET_ID_0: PacketId = PacketId::const_tc(true, TEST_APID_0);
+    const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
     const TEST_APID_1: u16 = 0x10;
-    const TEST_PACKET_ID_1: PacketId = PacketId::const_tc(true, TEST_APID_1);
+    const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1);
+
+    #[derive(Default)]
+    pub struct SimpleValidator(pub HashSet<PacketId>);
+
+    impl SpacePacketValidator for SimpleValidator {
+        fn validate(&self, sp_header: &SpHeader, _raw_buf: &[u8]) -> SpValidity {
+            if self.0.contains(&sp_header.packet_id()) {
+                return SpValidity::Valid;
+            }
+            // Simple case: Assume that the interface always contains valid space packets.
+            SpValidity::Skip
+        }
+    }
 
     fn generic_tmtc_server(
         addr: &SocketAddr,
-        tc_receiver: SyncTcCacher,
+        tc_sender: mpsc::Sender<PacketAsVec>,
         tm_source: SyncTmSource,
-        packet_id_lookup: HashSet<PacketId>,
-    ) -> TcpSpacepacketsServer<(), (), SyncTmSource, SyncTcCacher> {
+        validator: SimpleValidator,
+        stop_signal: Option<Arc<AtomicBool>>,
+    ) -> TcpSpacepacketsServer<
+        SyncTmSource,
+        mpsc::Sender<PacketAsVec>,
+        SimpleValidator,
+        ConnectionFinishedHandler,
+        (),
+        GenericSendError,
+    > {
         TcpSpacepacketsServer::new(
-            ServerConfig::new(*addr, Duration::from_millis(2), 1024, 1024),
+            ServerConfig::new(TCP_SERVER_ID, *addr, Duration::from_millis(2), 1024, 1024),
             tm_source,
-            tc_receiver,
-            Box::new(packet_id_lookup),
+            tc_sender,
+            validator,
+            ConnectionFinishedHandler::default(),
+            stop_signal,
         )
         .expect("TCP server generation failed")
     }
@@ -207,15 +244,16 @@ mod tests {
     #[test]
     fn test_basic_tc_only() {
         let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
-        let tc_receiver = SyncTcCacher::default();
+        let (tc_sender, tc_receiver) = mpsc::channel();
         let tm_source = SyncTmSource::default();
-        let mut packet_id_lookup = HashSet::new();
-        packet_id_lookup.insert(TEST_PACKET_ID_0);
+        let mut validator = SimpleValidator::default();
+        validator.0.insert(TEST_PACKET_ID_0);
         let mut tcp_server = generic_tmtc_server(
             &auto_port_addr,
-            tc_receiver.clone(),
+            tc_sender.clone(),
             tm_source,
-            packet_id_lookup,
+            validator,
+            None,
         );
         let dest_addr = tcp_server
             .local_addr()
@@ -224,17 +262,24 @@ mod tests {
         let set_if_done = conn_handled.clone();
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_next_connection();
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
             let conn_result = result.unwrap();
-            assert_eq!(conn_result.num_received_tcs, 1);
-            assert_eq!(conn_result.num_sent_tms, 0);
+            matches!(conn_result, ConnectionResult::HandledConnections(1));
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_last_connection(0, 1);
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_no_connections_left();
             set_if_done.store(true, Ordering::Relaxed);
         });
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let ping_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
         let tc_0 = ping_tc.to_vec().expect("packet generation failed");
         let mut stream = TcpStream::connect(dest_addr).expect("connecting to TCP server failed");
         stream
@@ -251,40 +296,40 @@ mod tests {
         if !conn_handled.load(Ordering::Relaxed) {
             panic!("connection was not handled properly");
         }
-        // Check that TC has arrived.
-        let mut tc_queue = tc_receiver.tc_queue.lock().unwrap();
-        assert_eq!(tc_queue.len(), 1);
-        assert_eq!(tc_queue.pop_front().unwrap(), tc_0);
+        let packet = tc_receiver.try_recv().expect("receiving TC failed");
+        assert_eq!(packet.packet, tc_0);
+        matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
     }
 
     #[test]
     fn test_multi_tc_multi_tm() {
         let auto_port_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 0);
-        let tc_receiver = SyncTcCacher::default();
+        let (tc_sender, tc_receiver) = mpsc::channel();
         let mut tm_source = SyncTmSource::default();
 
         // Add telemetry
         let mut total_tm_len = 0;
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 1, None, true);
+        let verif_tm =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 1, 1, &[], true);
         let tm_0 = verif_tm.to_vec().expect("writing packet failed");
         total_tm_len += tm_0.len();
         tm_source.add_tm(&tm_0);
-        let mut sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
-        let verif_tm = PusTcCreator::new_simple(&mut sph, 1, 3, None, true);
+        let verif_tm =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 1, 3, &[], true);
         let tm_1 = verif_tm.to_vec().expect("writing packet failed");
         total_tm_len += tm_1.len();
         tm_source.add_tm(&tm_1);
 
         // Set up server
-        let mut packet_id_lookup = HashSet::new();
-        packet_id_lookup.insert(TEST_PACKET_ID_0);
-        packet_id_lookup.insert(TEST_PACKET_ID_1);
+        let mut validator = SimpleValidator::default();
+        validator.0.insert(TEST_PACKET_ID_0);
+        validator.0.insert(TEST_PACKET_ID_1);
         let mut tcp_server = generic_tmtc_server(
             &auto_port_addr,
-            tc_receiver.clone(),
+            tc_sender.clone(),
             tm_source,
-            packet_id_lookup,
+            validator,
+            None,
         );
         let dest_addr = tcp_server
             .local_addr()
@@ -294,16 +339,20 @@ mod tests {
 
         // Call the connection handler in separate thread, does block.
         thread::spawn(move || {
-            let result = tcp_server.handle_next_connection();
+            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(100)));
             if result.is_err() {
                 panic!("handling connection failed: {:?}", result.unwrap_err());
             }
             let conn_result = result.unwrap();
-            assert_eq!(
-                conn_result.num_received_tcs, 2,
-                "wrong number of received TCs"
-            );
-            assert_eq!(conn_result.num_sent_tms, 2, "wrong number of sent TMs");
+            matches!(conn_result, ConnectionResult::HandledConnections(1));
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_last_connection(2, 2);
+            tcp_server
+                .generic_server
+                .finished_handler
+                .check_no_connections_left();
             set_if_done.store(true, Ordering::Relaxed);
         });
         let mut stream = TcpStream::connect(dest_addr).expect("connecting to TCP server failed");
@@ -312,14 +361,14 @@ mod tests {
             .expect("setting reas timeout failed");
 
         // Send telecommands
-        let mut sph = SpHeader::tc_unseg(TEST_APID_0, 0, 0).unwrap();
-        let ping_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let ping_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true);
         let tc_0 = ping_tc.to_vec().expect("ping tc creation failed");
         stream
             .write_all(&tc_0)
             .expect("writing to TCP server failed");
-        let mut sph = SpHeader::tc_unseg(TEST_APID_1, 0, 0).unwrap();
-        let action_tc = PusTcCreator::new_simple(&mut sph, 8, 0, None, true);
+        let action_tc =
+            PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true);
         let tc_1 = action_tc.to_vec().expect("action tc creation failed");
         stream
             .write_all(&tc_1)
@@ -354,9 +403,10 @@ mod tests {
             panic!("connection was not handled properly");
         }
         // Check that TC has arrived.
-        let mut tc_queue = tc_receiver.tc_queue.lock().unwrap();
-        assert_eq!(tc_queue.len(), 2);
-        assert_eq!(tc_queue.pop_front().unwrap(), tc_0);
-        assert_eq!(tc_queue.pop_front().unwrap(), tc_1);
+        let packet_0 = tc_receiver.try_recv().expect("receiving TC failed");
+        assert_eq!(packet_0.packet, tc_0);
+        let packet_1 = tc_receiver.try_recv().expect("receiving TC failed");
+        assert_eq!(packet_1.packet, tc_1);
+        matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
     }
 }

satrs/src/hal/std/udp_server.rs

@@ -1,7 +1,8 @@
 //! Generic UDP TC server.
-use crate::tmtc::{ReceivesTc, ReceivesTcCore};
-use std::boxed::Box;
-use std::io::{Error, ErrorKind};
+use crate::tmtc::PacketSenderRaw;
+use crate::ComponentId;
+use core::fmt::Debug;
+use std::io::{self, ErrorKind};
 use std::net::{SocketAddr, ToSocketAddrs, UdpSocket};
 use std::vec;
 use std::vec::Vec;
@@ -11,45 +12,46 @@ use std::vec::Vec;
 ///
 /// It caches all received telecomands into a vector. The maximum expected telecommand size should
 /// be declared upfront. This avoids dynamic allocation during run-time. The user can specify a TC
-/// receiver in form of a special trait object which implements [ReceivesTc]. Please note that the
-/// receiver should copy out the received data if it the data is required past the
-/// [ReceivesTcCore::pass_tc] call.
+/// sender in form of a special trait object which implements [PacketSenderRaw]. For example, this
+/// can be used to send the telecommands to a centralized TC source component for further
+/// processing and routing.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
+/// use std::sync::mpsc;
 /// use spacepackets::ecss::WritablePusPacket;
 /// use satrs::hal::std::udp_server::UdpTcServer;
-/// use satrs::tmtc::{ReceivesTc, ReceivesTcCore};
+/// use satrs::ComponentId;
+/// use satrs::tmtc::PacketSenderRaw;
 /// use spacepackets::SpHeader;
 /// use spacepackets::ecss::tc::PusTcCreator;
 ///
-/// #[derive (Default)]
-/// struct PingReceiver {}
-/// impl ReceivesTcCore for PingReceiver {
-///    type Error = ();
-///    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-///         assert_eq!(tc_raw.len(), 13);
-///         Ok(())
-///     }
-/// }
+/// const UDP_SERVER_ID: ComponentId = 0x05;
 ///
-/// let mut buf = [0; 32];
+/// let (packet_sender, packet_receiver) = mpsc::channel();
 /// let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7777);
-/// let ping_receiver = PingReceiver::default();
-/// let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver))
+/// let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, packet_sender)
 ///       .expect("Creating UDP TMTC server failed");
-/// let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
-/// let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
-/// let len = pus_tc
-///     .write_to_bytes(&mut buf)
-///     .expect("Error writing PUS TC packet");
-/// assert_eq!(len, 13);
-/// let client = UdpSocket::bind("127.0.0.1:7778").expect("Connecting to UDP server failed");
+/// let sph = SpHeader::new_from_apid(0x02);
+/// let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
+/// // Can not fail.
+/// let ping_tc_raw = pus_tc.to_vec().unwrap();
+///
+/// // Now create a UDP client and send the ping telecommand to the server.
+/// let client = UdpSocket::bind("127.0.0.1:0").expect("creating UDP client failed");
 /// client
-///     .send_to(&buf[0..len], dest_addr)
+///     .send_to(&ping_tc_raw, dest_addr)
 ///     .expect("Error sending PUS TC via UDP");
+/// let recv_result = udp_tc_server.try_recv_tc();
+/// assert!(recv_result.is_ok());
+/// // The packet is received by the UDP TC server and sent via the mpsc channel.
+/// let sent_packet_with_sender = packet_receiver.try_recv().expect("expected telecommand");
+/// assert_eq!(sent_packet_with_sender.packet, ping_tc_raw);
+/// assert_eq!(sent_packet_with_sender.sender_id, UDP_SERVER_ID);
+/// // No more packets received.
+/// matches!(packet_receiver.try_recv(), Err(mpsc::TryRecvError::Empty));
 /// ```
 ///
 /// The [satrs-example crate](https://egit.irs.uni-stuttgart.de/rust/fsrc-launchpad/src/branch/main/satrs-example)
@@ -57,65 +59,45 @@ use std::vec::Vec;
 /// [example code](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-example/src/tmtc.rs#L67)
 /// on how to use this TC server. It uses the server to receive PUS telecommands on a specific port
 /// and then forwards them to a generic CCSDS packet receiver.
-pub struct UdpTcServer<E> {
+pub struct UdpTcServer<TcSender: PacketSenderRaw<Error = SendError>, SendError> {
+    pub id: ComponentId,
     pub socket: UdpSocket,
     recv_buf: Vec<u8>,
     sender_addr: Option<SocketAddr>,
-    tc_receiver: Box<dyn ReceivesTc<Error = E>>,
+    pub tc_sender: TcSender,
 }
 
-#[derive(Debug)]
-pub enum ReceiveResult<E> {
+#[derive(Debug, thiserror::Error)]
+pub enum ReceiveResult<SendError: Debug + 'static> {
+    #[error("nothing was received")]
     NothingReceived,
-    IoError(Error),
-    ReceiverError(E),
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    #[error(transparent)]
+    Send(SendError),
 }
 
-impl<E> From<Error> for ReceiveResult<E> {
-    fn from(e: Error) -> Self {
-        ReceiveResult::IoError(e)
-    }
-}
-
-impl<E: PartialEq> PartialEq for ReceiveResult<E> {
-    fn eq(&self, other: &Self) -> bool {
-        use ReceiveResult::*;
-        match (self, other) {
-            (IoError(ref e), IoError(ref other_e)) => e.kind() == other_e.kind(),
-            (NothingReceived, NothingReceived) => true,
-            (ReceiverError(e), ReceiverError(other_e)) => e == other_e,
-            _ => false,
-        }
-    }
-}
-
-impl<E: Eq + PartialEq> Eq for ReceiveResult<E> {}
-
-impl<E: 'static> ReceivesTcCore for UdpTcServer<E> {
-    type Error = E;
-
-    fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-        self.tc_receiver.pass_tc(tc_raw)
-    }
-}
-
-impl<E: 'static> UdpTcServer<E> {
+impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>
+    UdpTcServer<TcSender, SendError>
+{
     pub fn new<A: ToSocketAddrs>(
+        id: ComponentId,
         addr: A,
         max_recv_size: usize,
-        tc_receiver: Box<dyn ReceivesTc<Error = E>>,
-    ) -> Result<Self, Error> {
+        tc_sender: TcSender,
+    ) -> Result<Self, io::Error> {
         let server = Self {
+            id,
             socket: UdpSocket::bind(addr)?,
             recv_buf: vec![0; max_recv_size],
             sender_addr: None,
-            tc_receiver,
+            tc_sender,
         };
         server.socket.set_nonblocking(true)?;
         Ok(server)
     }
 
-    pub fn try_recv_tc(&mut self) -> Result<(usize, SocketAddr), ReceiveResult<E>> {
+    pub fn try_recv_tc(&mut self) -> Result<(usize, SocketAddr), ReceiveResult<SendError>> {
         let res = match self.socket.recv_from(&mut self.recv_buf) {
             Ok(res) => res,
             Err(e) => {
@@ -128,9 +110,9 @@ impl<E: 'static> UdpTcServer<E> {
         };
         let (num_bytes, from) = res;
         self.sender_addr = Some(from);
-        self.tc_receiver
-            .pass_tc(&self.recv_buf[0..num_bytes])
-            .map_err(|e| ReceiveResult::ReceiverError(e))?;
+        self.tc_sender
+            .send_packet(self.id, &self.recv_buf[0..num_bytes])
+            .map_err(ReceiveResult::Send)?;
         Ok(res)
     }
 
@@ -142,29 +124,35 @@ impl<E: 'static> UdpTcServer<E> {
 #[cfg(test)]
 mod tests {
     use crate::hal::std::udp_server::{ReceiveResult, UdpTcServer};
-    use crate::tmtc::ReceivesTcCore;
+    use crate::queue::GenericSendError;
+    use crate::tmtc::PacketSenderRaw;
+    use crate::ComponentId;
+    use core::cell::RefCell;
     use spacepackets::ecss::tc::PusTcCreator;
     use spacepackets::ecss::WritablePusPacket;
     use spacepackets::SpHeader;
-    use std::boxed::Box;
     use std::collections::VecDeque;
     use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
     use std::vec::Vec;
 
     fn is_send<T: Send>(_: &T) {}
 
+    const UDP_SERVER_ID: ComponentId = 0x05;
+
     #[derive(Default)]
     struct PingReceiver {
-        pub sent_cmds: VecDeque<Vec<u8>>,
+        pub sent_cmds: RefCell<VecDeque<Vec<u8>>>,
     }
 
-    impl ReceivesTcCore for PingReceiver {
-        type Error = ();
+    impl PacketSenderRaw for PingReceiver {
+        type Error = GenericSendError;
 
-        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
+        fn send_packet(&self, sender_id: ComponentId, tc_raw: &[u8]) -> Result<(), Self::Error> {
+            assert_eq!(sender_id, UDP_SERVER_ID);
             let mut sent_data = Vec::new();
             sent_data.extend_from_slice(tc_raw);
-            self.sent_cmds.push_back(sent_data);
+            let mut queue = self.sent_cmds.borrow_mut();
+            queue.push_back(sent_data);
             Ok(())
         }
     }
@@ -175,11 +163,11 @@ mod tests {
         let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7777);
         let ping_receiver = PingReceiver::default();
         is_send(&ping_receiver);
-        let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver))
+        let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, ping_receiver)
             .expect("Creating UDP TMTC server failed");
         is_send(&udp_tc_server);
-        let mut sph = SpHeader::tc_unseg(0x02, 0, 0).unwrap();
-        let pus_tc = PusTcCreator::new_simple(&mut sph, 17, 1, None, true);
+        let sph = SpHeader::new_from_apid(0x02);
+        let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true);
         let len = pus_tc
             .write_to_bytes(&mut buf)
             .expect("Error writing PUS TC packet");
@@ -195,9 +183,10 @@ mod tests {
             udp_tc_server.last_sender().expect("No sender set"),
             local_addr
         );
-        let ping_receiver: &mut PingReceiver = udp_tc_server.tc_receiver.downcast_mut().unwrap();
-        assert_eq!(ping_receiver.sent_cmds.len(), 1);
-        let sent_cmd = ping_receiver.sent_cmds.pop_front().unwrap();
+        let ping_receiver = &mut udp_tc_server.tc_sender;
+        let mut queue = ping_receiver.sent_cmds.borrow_mut();
+        assert_eq!(queue.len(), 1);
+        let sent_cmd = queue.pop_front().unwrap();
         assert_eq!(sent_cmd, buf[0..len]);
     }
 
@@ -205,11 +194,11 @@ mod tests {
     fn test_nothing_received() {
         let dest_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 7779);
         let ping_receiver = PingReceiver::default();
-        let mut udp_tc_server = UdpTcServer::new(dest_addr, 2048, Box::new(ping_receiver))
+        let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, ping_receiver)
             .expect("Creating UDP TMTC server failed");
         let res = udp_tc_server.try_recv_tc();
         assert!(res.is_err());
         let err = res.unwrap_err();
-        assert_eq!(err, ReceiveResult::NothingReceived);
+        matches!(err, ReceiveResult::NothingReceived);
     }
 }

satrs/src/hk.rs

@@ -1,40 +1,40 @@
-use crate::{
-    pus::verification::{TcStateAccepted, VerificationToken},
-    TargetId,
-};
+use crate::ComponentId;
 
 pub type CollectionIntervalFactor = u32;
+/// Unique Identifier for a certain housekeeping dataset.
 pub type UniqueId = u32;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum HkRequest {
-    OneShot(UniqueId),
-    Enable(UniqueId),
-    Disable(UniqueId),
-    ModifyCollectionInterval(UniqueId, CollectionIntervalFactor),
+pub struct HkRequest {
+    pub unique_id: UniqueId,
+    pub variant: HkRequestVariant,
+}
+
+impl HkRequest {
+    pub fn new(unique_id: UniqueId, variant: HkRequestVariant) -> Self {
+        Self { unique_id, variant }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum HkRequestVariant {
+    OneShot,
+    EnablePeriodic,
+    DisablePeriodic,
+    ModifyCollectionInterval(CollectionIntervalFactor),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct TargetedHkRequest {
-    pub target_id: TargetId,
-    pub hk_request: HkRequest,
+    pub target_id: ComponentId,
+    pub hk_request: HkRequestVariant,
 }
 
 impl TargetedHkRequest {
-    pub fn new(target_id: TargetId, hk_request: HkRequest) -> Self {
+    pub fn new(target_id: ComponentId, hk_request: HkRequestVariant) -> Self {
         Self {
             target_id,
             hk_request,
         }
     }
 }
-
-pub trait PusHkRequestRouter {
-    type Error;
-    fn route(
-        &self,
-        target_id: TargetId,
-        hk_request: HkRequest,
-        token: VerificationToken<TcStateAccepted>,
-    ) -> Result<(), Self::Error>;
-}

satrs/src/lib.rs

@@ -14,7 +14,7 @@
 //!  - The [pus] module which provides special support for projects using
 //!    the [ECSS PUS C standard](https://ecss.nl/standard/ecss-e-st-70-41c-space-engineering-telemetry-and-telecommand-packet-utilization-15-april-2016/).
 #![no_std]
-#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![cfg_attr(docs_rs, feature(doc_auto_cfg))]
 #[cfg(feature = "alloc")]
 extern crate alloc;
 #[cfg(feature = "alloc")]
@@ -23,18 +23,15 @@ extern crate downcast_rs;
 extern crate std;
 
 #[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod cfdp;
 pub mod encoding;
-#[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
 pub mod event_man;
 pub mod events;
 #[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod executable;
 pub mod hal;
-pub mod objects;
+#[cfg(feature = "std")]
+pub mod mode_tree;
 pub mod pool;
 pub mod power;
 pub mod pus;
@@ -42,6 +39,7 @@ pub mod queue;
 pub mod request;
 pub mod res_code;
 pub mod seq_count;
+pub mod time;
 pub mod tmtc;
 
 pub mod action;
@@ -51,8 +49,82 @@ pub mod params;
 
 pub use spacepackets;
 
-/// Generic channel ID type.
-pub type ChannelId = u32;
+use spacepackets::PacketId;
 
-/// Generic target ID type.
-pub type TargetId = u64;
+/// Generic component ID type.
+pub type ComponentId = u64;
+
+pub trait ValidatorU16Id {
+    fn validate(&self, id: u16) -> bool;
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for alloc::vec::Vec<u16> {
+    fn validate(&self, id: u16) -> bool {
+        self.contains(&id)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for hashbrown::HashSet<u16> {
+    fn validate(&self, id: u16) -> bool {
+        self.contains(&id)
+    }
+}
+
+impl ValidatorU16Id for u16 {
+    fn validate(&self, id: u16) -> bool {
+        id == *self
+    }
+}
+
+impl ValidatorU16Id for &u16 {
+    fn validate(&self, id: u16) -> bool {
+        id == **self
+    }
+}
+
+impl ValidatorU16Id for [u16] {
+    fn validate(&self, id: u16) -> bool {
+        self.binary_search(&id).is_ok()
+    }
+}
+
+impl ValidatorU16Id for &[u16] {
+    fn validate(&self, id: u16) -> bool {
+        self.binary_search(&id).is_ok()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for alloc::vec::Vec<spacepackets::PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl ValidatorU16Id for hashbrown::HashSet<spacepackets::PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+#[cfg(feature = "std")]
+impl ValidatorU16Id for std::collections::HashSet<PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+impl ValidatorU16Id for [PacketId] {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.binary_search(&PacketId::from(packet_id)).is_ok()
+    }
+}
+
+impl ValidatorU16Id for &[PacketId] {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.binary_search(&PacketId::from(packet_id)).is_ok()
+    }
+}

satrs/src/mode.rs

@@ -1,67 +1,95 @@
 use core::mem::size_of;
+use satrs_shared::res_code::ResultU16;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use spacepackets::ByteConversionError;
 
-use crate::TargetId;
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
+
+#[cfg(feature = "std")]
+pub use std_mod::*;
+
+use crate::{
+    queue::GenericTargetedMessagingError,
+    request::{GenericMessage, MessageMetadata, MessageReceiver, MessageReceiverWithId, RequestId},
+    ComponentId,
+};
+
+pub type Mode = u32;
+pub type Submode = u16;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ModeAndSubmode {
-    mode: u32,
-    submode: u16,
+    mode: Mode,
+    submode: Submode,
 }
 
 impl ModeAndSubmode {
-    pub const fn new_mode_only(mode: u32) -> Self {
+    pub const RAW_LEN: usize = size_of::<Mode>() + size_of::<Submode>();
+
+    pub const fn new_mode_only(mode: Mode) -> Self {
         Self { mode, submode: 0 }
     }
 
-    pub const fn new(mode: u32, submode: u16) -> Self {
+    pub const fn new(mode: Mode, submode: Submode) -> Self {
         Self { mode, submode }
     }
 
-    pub fn raw_len() -> usize {
-        size_of::<u32>() + size_of::<u16>()
-    }
-
     pub fn from_be_bytes(buf: &[u8]) -> Result<Self, ByteConversionError> {
         if buf.len() < 6 {
             return Err(ByteConversionError::FromSliceTooSmall {
-                expected: 6,
+                expected: Self::RAW_LEN,
                 found: buf.len(),
             });
         }
         Ok(Self {
-            mode: u32::from_be_bytes(buf[0..4].try_into().unwrap()),
-            submode: u16::from_be_bytes(buf[4..6].try_into().unwrap()),
+            mode: Mode::from_be_bytes(buf[0..size_of::<Mode>()].try_into().unwrap()),
+            submode: Submode::from_be_bytes(
+                buf[size_of::<Mode>()..size_of::<Mode>() + size_of::<Submode>()]
+                    .try_into()
+                    .unwrap(),
+            ),
         })
     }
 
-    pub fn mode(&self) -> u32 {
+    pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        if buf.len() < Self::RAW_LEN {
+            return Err(ByteConversionError::ToSliceTooSmall {
+                expected: Self::RAW_LEN,
+                found: buf.len(),
+            });
+        }
+        buf[0..size_of::<Mode>()].copy_from_slice(&self.mode.to_be_bytes());
+        buf[size_of::<Mode>()..Self::RAW_LEN].copy_from_slice(&self.submode.to_be_bytes());
+        Ok(Self::RAW_LEN)
+    }
+
+    pub fn mode(&self) -> Mode {
         self.mode
     }
 
-    pub fn submode(&self) -> u16 {
+    pub fn submode(&self) -> Submode {
         self.submode
     }
 }
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct TargetedModeCommand {
-    pub address: TargetId,
+    pub address: ComponentId,
     pub mode_submode: ModeAndSubmode,
 }
 
 impl TargetedModeCommand {
-    pub const fn new(address: TargetId, mode_submode: ModeAndSubmode) -> Self {
+    pub const fn new(address: ComponentId, mode_submode: ModeAndSubmode) -> Self {
         Self {
             address,
             mode_submode,
         }
     }
 
-    pub fn address(&self) -> TargetId {
+    pub fn address(&self) -> ComponentId {
         self.address
     }
 
@@ -81,6 +109,8 @@ impl TargetedModeCommand {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ModeRequest {
+    /// Mode information. Can be used to notify other components of changed modes.
+    ModeInfo(ModeAndSubmode),
     SetMode(ModeAndSubmode),
     ReadMode,
     AnnounceMode,
@@ -90,6 +120,471 @@ pub enum ModeRequest {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct TargetedModeRequest {
-    target_id: TargetId,
+    target_id: ComponentId,
     mode_request: ModeRequest,
 }
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ModeReply {
+    /// Reply to a mode request to confirm the commanded mode was reached.
+    ModeReply(ModeAndSubmode),
+    // Can not reach the commanded mode. Contains a reason as a [ResultU16].
+    CantReachMode(ResultU16),
+    /// We are in the wrong mode for unknown reasons. Contains the expected and reached mode.
+    WrongMode {
+        expected: ModeAndSubmode,
+        reached: ModeAndSubmode,
+    },
+}
+
+pub type GenericModeReply = GenericMessage<ModeReply>;
+
+pub trait ModeRequestSender {
+    fn local_channel_id(&self) -> ComponentId;
+    fn send_mode_request(
+        &self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        request: ModeRequest,
+    ) -> Result<(), GenericTargetedMessagingError>;
+}
+
+pub trait ModeRequestReceiver {
+    fn try_recv_mode_request(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError>;
+}
+
+impl<R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+    for MessageReceiverWithId<ModeRequest, R>
+{
+    fn try_recv_mode_request(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+        self.try_recv_message()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ModeError {
+    Messaging(GenericTargetedMessagingError),
+}
+
+impl From<GenericTargetedMessagingError> for ModeError {
+    fn from(value: GenericTargetedMessagingError) -> Self {
+        Self::Messaging(value)
+    }
+}
+
+pub trait ModeProvider {
+    fn mode_and_submode(&self) -> ModeAndSubmode;
+
+    fn mode(&self) -> Mode {
+        self.mode_and_submode().mode()
+    }
+
+    fn submode(&self) -> Submode {
+        self.mode_and_submode().submode()
+    }
+}
+
+pub trait ModeRequestHandler: ModeProvider {
+    type Error;
+
+    fn start_transition(
+        &mut self,
+        requestor: MessageMetadata,
+        mode_and_submode: ModeAndSubmode,
+    ) -> Result<(), Self::Error>;
+
+    fn announce_mode(&self, requestor_info: Option<MessageMetadata>, recursive: bool);
+
+    fn handle_mode_reached(
+        &mut self,
+        requestor_info: Option<MessageMetadata>,
+    ) -> Result<(), Self::Error>;
+
+    fn handle_mode_info(
+        &mut self,
+        requestor_info: MessageMetadata,
+        info: ModeAndSubmode,
+    ) -> Result<(), Self::Error>;
+
+    fn send_mode_reply(
+        &self,
+        requestor_info: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), Self::Error>;
+
+    fn handle_mode_request(
+        &mut self,
+        request: GenericMessage<ModeRequest>,
+    ) -> Result<(), Self::Error> {
+        match request.message {
+            ModeRequest::SetMode(mode_and_submode) => {
+                self.start_transition(request.requestor_info, mode_and_submode)
+            }
+            ModeRequest::ReadMode => self.send_mode_reply(
+                request.requestor_info,
+                ModeReply::ModeReply(self.mode_and_submode()),
+            ),
+            ModeRequest::AnnounceMode => {
+                self.announce_mode(Some(request.requestor_info), false);
+                Ok(())
+            }
+            ModeRequest::AnnounceModeRecursive => {
+                self.announce_mode(Some(request.requestor_info), true);
+                Ok(())
+            }
+            ModeRequest::ModeInfo(info) => self.handle_mode_info(request.requestor_info, info),
+        }
+    }
+}
+
+pub trait ModeReplyReceiver {
+    fn try_recv_mode_reply(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError>;
+}
+
+impl<R: MessageReceiver<ModeReply>> ModeReplyReceiver for MessageReceiverWithId<ModeReply, R> {
+    fn try_recv_mode_reply(
+        &self,
+    ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+        self.try_recv_message()
+    }
+}
+
+pub trait ModeReplySender {
+    fn local_channel_id(&self) -> ComponentId;
+
+    /// The requestor is assumed to be the target of the reply.
+    fn send_mode_reply(
+        &self,
+        requestor_info: MessageMetadata,
+        reply: ModeReply,
+    ) -> Result<(), GenericTargetedMessagingError>;
+}
+
+#[cfg(feature = "alloc")]
+pub mod alloc_mod {
+    use crate::request::{
+        MessageSender, MessageSenderAndReceiver, MessageSenderMap, RequestAndReplySenderAndReceiver,
+    };
+
+    use super::*;
+
+    impl<S: MessageSender<ModeReply>> MessageSenderMap<ModeReply, S> {
+        pub fn send_mode_reply(
+            &self,
+            requestor_info: MessageMetadata,
+            target_id: ComponentId,
+            request: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(requestor_info, target_id, request)
+        }
+
+        pub fn add_reply_target(&mut self, target_id: ComponentId, request_sender: S) {
+            self.add_message_target(target_id, request_sender)
+        }
+    }
+
+    impl<FROM, S: MessageSender<ModeReply>, R: MessageReceiver<FROM>> ModeReplySender
+        for MessageSenderAndReceiver<ModeReply, FROM, S, R>
+    {
+        fn local_channel_id(&self) -> ComponentId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_reply(
+            &self,
+            requestor_info: MessageMetadata,
+            request: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.message_sender_map.send_mode_reply(
+                MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
+                requestor_info.sender_id(),
+                request,
+            )
+        }
+    }
+
+    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeReply>> ModeReplyReceiver
+        for MessageSenderAndReceiver<TO, ModeReply, S, R>
+    {
+        fn try_recv_mode_reply(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+            self.message_receiver.try_recv_message()
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        pub fn add_reply_target(&mut self, target_id: ComponentId, reply_sender: S1) {
+            self.reply_sender_map
+                .add_message_target(target_id, reply_sender)
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > ModeReplySender for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        fn local_channel_id(&self) -> ComponentId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_reply(
+            &self,
+            requestor_info: MessageMetadata,
+            request: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.reply_sender_map.send_mode_reply(
+                MessageMetadata::new(requestor_info.request_id(), self.local_channel_id()),
+                requestor_info.sender_id(),
+                request,
+            )
+        }
+    }
+
+    impl<
+            REQUEST,
+            S0: MessageSender<REQUEST>,
+            R0: MessageReceiver<ModeReply>,
+            S1: MessageSender<ModeReply>,
+            R1: MessageReceiver<REQUEST>,
+        > ModeReplyReceiver
+        for RequestAndReplySenderAndReceiver<REQUEST, ModeReply, S0, R0, S1, R1>
+    {
+        fn try_recv_mode_reply(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+            self.reply_receiver.try_recv_message()
+        }
+    }
+
+    /// Helper type definition for a mode handler which can handle mode requests.
+    pub type ModeRequestHandlerInterface<S, R> =
+        MessageSenderAndReceiver<ModeReply, ModeRequest, S, R>;
+
+    impl<S: MessageSender<ModeReply>, R: MessageReceiver<ModeRequest>>
+        ModeRequestHandlerInterface<S, R>
+    {
+        pub fn try_recv_mode_request(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+            self.try_recv_message()
+        }
+
+        pub fn send_mode_reply(
+            &self,
+            requestor_info: MessageMetadata,
+            reply: ModeReply,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(
+                requestor_info.request_id(),
+                requestor_info.sender_id(),
+                reply,
+            )
+        }
+    }
+
+    /// Helper type defintion for a mode handler object which can send mode requests and receive
+    /// mode replies.
+    pub type ModeRequestorInterface<S, R> = MessageSenderAndReceiver<ModeRequest, ModeReply, S, R>;
+
+    impl<S: MessageSender<ModeRequest>, R: MessageReceiver<ModeReply>> ModeRequestorInterface<S, R> {
+        pub fn try_recv_mode_reply(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeReply>>, GenericTargetedMessagingError> {
+            self.try_recv_message()
+        }
+
+        pub fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ComponentId,
+            reply: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(request_id, target_id, reply)
+        }
+    }
+
+    /// Helper type defintion for a mode handler object which can both send mode requests and
+    /// process mode requests.
+    pub type ModeInterface<S0, R0, S1, R1> =
+        RequestAndReplySenderAndReceiver<ModeRequest, ModeReply, S0, R0, S1, R1>;
+
+    impl<S: MessageSender<ModeRequest>> MessageSenderMap<ModeRequest, S> {
+        pub fn send_mode_request(
+            &self,
+            requestor_info: MessageMetadata,
+            target_id: ComponentId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(requestor_info, target_id, request)
+        }
+
+        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S) {
+            self.add_message_target(target_id, request_sender)
+        }
+    }
+
+    /*
+    impl<S: MessageSender<ModeRequest>> ModeRequestSender for MessageSenderMapWithId<ModeRequest, S> {
+        fn local_channel_id(&self) -> ComponentId {
+            self.local_channel_id
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ComponentId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.send_message(request_id, target_id, request)
+        }
+    }
+    */
+
+    impl<TO, S: MessageSender<TO>, R: MessageReceiver<ModeRequest>> ModeRequestReceiver
+        for MessageSenderAndReceiver<TO, ModeRequest, S, R>
+    {
+        fn try_recv_mode_request(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+            self.message_receiver.try_recv_message()
+        }
+    }
+
+    impl<FROM, S: MessageSender<ModeRequest>, R: MessageReceiver<FROM>> ModeRequestSender
+        for MessageSenderAndReceiver<ModeRequest, FROM, S, R>
+    {
+        fn local_channel_id(&self) -> ComponentId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ComponentId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.message_sender_map.send_mode_request(
+                MessageMetadata::new(request_id, self.local_channel_id()),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        pub fn add_request_target(&mut self, target_id: ComponentId, request_sender: S0) {
+            self.request_sender_map
+                .add_message_target(target_id, request_sender)
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > ModeRequestSender
+        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        fn local_channel_id(&self) -> ComponentId {
+            self.local_channel_id_generic()
+        }
+
+        fn send_mode_request(
+            &self,
+            request_id: RequestId,
+            target_id: ComponentId,
+            request: ModeRequest,
+        ) -> Result<(), GenericTargetedMessagingError> {
+            self.request_sender_map.send_mode_request(
+                MessageMetadata::new(request_id, self.local_channel_id()),
+                target_id,
+                request,
+            )
+        }
+    }
+
+    impl<
+            REPLY,
+            S0: MessageSender<ModeRequest>,
+            R0: MessageReceiver<REPLY>,
+            S1: MessageSender<REPLY>,
+            R1: MessageReceiver<ModeRequest>,
+        > ModeRequestReceiver
+        for RequestAndReplySenderAndReceiver<ModeRequest, REPLY, S0, R0, S1, R1>
+    {
+        fn try_recv_mode_request(
+            &self,
+        ) -> Result<Option<GenericMessage<ModeRequest>>, GenericTargetedMessagingError> {
+            self.request_receiver.try_recv_message()
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+pub mod std_mod {
+    use std::sync::mpsc;
+
+    use super::*;
+
+    pub type ModeRequestHandlerMpsc = ModeRequestHandlerInterface<
+        mpsc::Sender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+    pub type ModeRequestHandlerMpscBounded = ModeRequestHandlerInterface<
+        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+
+    pub type ModeRequestorMpsc = ModeRequestorInterface<
+        mpsc::Sender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+    >;
+    pub type ModeRequestorBoundedMpsc = ModeRequestorInterface<
+        mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+    >;
+
+    pub type ModeRequestorAndHandlerMpsc = ModeInterface<
+        mpsc::Sender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        mpsc::Sender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+    pub type ModeRequestorAndHandlerMpscBounded = ModeInterface<
+        mpsc::SyncSender<GenericMessage<ModeRequest>>,
+        mpsc::Receiver<GenericMessage<ModeReply>>,
+        mpsc::SyncSender<GenericMessage<ModeReply>>,
+        mpsc::Receiver<GenericMessage<ModeRequest>>,
+    >;
+}
+
+#[cfg(test)]
+mod tests {}

satrs/src/mode_tree.rs

@@ -0,0 +1,37 @@
+use alloc::vec::Vec;
+use hashbrown::HashMap;
+
+use crate::{
+    mode::{Mode, ModeAndSubmode, Submode},
+    ComponentId,
+};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum TableEntryType {
+    /// Target table containing information of the expected children modes for  given mode.
+    Target,
+    /// Sequence table which contains information about how to reach a target table, including
+    /// the order of the sequences.
+    Sequence,
+}
+
+pub struct ModeTableEntry {
+    /// Name of respective table entry.
+    pub name: &'static str,
+    /// Target channel ID.
+    pub channel_id: ComponentId,
+    pub mode_submode: ModeAndSubmode,
+    pub allowed_submode_mask: Option<Submode>,
+    pub check_success: bool,
+}
+
+pub struct ModeTableMapValue {
+    /// Name for a given mode table entry.
+    pub name: &'static str,
+    pub entries: Vec<ModeTableEntry>,
+}
+
+pub type ModeTable = HashMap<Mode, ModeTableMapValue>;
+
+#[cfg(test)]
+mod tests {}