continue updating embedded examples

Merge pull request 'CI fix and naming improvement' (#249 ) from example-ci-fix into main
Reviewed-on: #249
2025-09-10 18:06:50 +02:00 · 2025-09-06 19:40:17 +02:00 · 2025-09-06 19:36:56 +02:00 · 2025-09-06 19:32:18 +02:00 · 2025-09-06 19:32:06 +02:00 · 2025-09-06 19:31:46 +02:00
79 changed files with 2723 additions and 2013 deletions
--- a/README.md
+++ b/README.md
@@ -1,9 +1,10 @@
 <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/)
+[![sat-rs book](https://img.shields.io/badge/sat--rs-book-darkgreen?style=flat)](https://robamu.github.io/sat-rs/book/)
 [![Crates.io](https://img.shields.io/crates/v/satrs)](https://crates.io/crates/satrs)
 [![docs.rs](https://img.shields.io/docsrs/satrs)](https://docs.rs/satrs)
+[![matrix chat](https://img.shields.io/matrix/sat-rs%3Amatrix.org)](https://matrix.to/#/#sat-rs:matrix.org)

 sat-rs
 =========
@@ -11,7 +12,7 @@ sat-rs
 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/)
+link to the [more high-level sat-rs book](https://robamu.github.io/sat-rs/book/)
 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
@@ -38,7 +39,7 @@ This project currently contains following crates:
   Example of a simple example on-board software using various sat-rs components which can be run
   on a host computer or on any system with a standard runtime like a Raspberry Pi.
 * [`satrs-minisim`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-minisim):
-   Mini-Simulator based on [asynchronix](https://github.com/asynchronics/asynchronix) which
+   Mini-Simulator based on [nexosim](https://github.com/asynchronics/nexosim) which
   simulates some physical devices for the `satrs-example` application device handlers.
 * [`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.
@@ -61,6 +62,8 @@ Each project has its own `CHANGELOG.md`.
   packet protocol implementations. This repository is re-exported in the
   [`satrs`](https://egit.irs.uni-stuttgart.de/rust/satrs/src/branch/main/satrs)
   crate.
+ * [`cfdp`](https://egit.irs.uni-stuttgart.de/rust/cfdp): CCSDS File Delivery Protocol
+   (CFDP) high-level library components.

 # Flight Heritage

--- a/embedded-examples/stm32f3-disco-rtic/Cargo.lock
+++ b/embedded-examples/stm32f3-disco-rtic/Cargo.lock
@@ -3,12 +3,21 @@
 version = 4

 [[package]]
-name = "accelerometer"
-version = "0.12.0"
+name = "aligned"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a4586d95cb0695e748760c9a751141eebb68265b1b20392a0f14db608679f7a"
+checksum = "377e4c0ba83e4431b10df45c1d4666f178ea9c552cac93e60c3a88bf32785923"
 dependencies = [
- "micromath",
+ "as-slice",
+]
+
+[[package]]
+name = "as-slice"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516"
+dependencies = [
+ "stable_deref_trait",
 ]

 [[package]]
@@ -23,7 +32,7 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
 dependencies = [
- "rustc_version 0.2.3",
+ "rustc_version",
 ]

 [[package]]
@@ -32,6 +41,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"

+[[package]]
+name = "bit_field"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"
+
 [[package]]
 name = "bitfield"
 version = "0.13.2"
@@ -45,15 +60,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
-name = "bxcan"
-version = "0.7.0"
+name = "bitflags"
+version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ac3d0c0a542d0ab5521211f873f62706a7136df415676f676d347e5a41dd80"
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+
+[[package]]
+name = "block-device-driver"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c051592f59fe68053524b4c4935249b806f72c1f544cfb7abe4f57c3be258e"
 dependencies = [
- "bitflags",
- "embedded-hal 0.2.7",
- "nb 1.1.0",
- "vcell",
+ "aligned",
 ]

 [[package]]
@@ -62,41 +80,17 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

-[[package]]
-name = "cast"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
-dependencies = [
- "rustc_version 0.4.1",
-]
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

-[[package]]
-name = "chrono"
-version = "0.4.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "cobs"
-version = "0.2.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
-
-[[package]]
-name = "cobs"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+checksum = "fea6d1b751c55bd9c0dda7d4ff752074e98f4765ae969664648bd193bb326d15"
 dependencies = [
 "thiserror",
 ]
@@ -200,29 +194,19 @@ dependencies = [

 [[package]]
 name = "defmt"
-version = "0.3.10"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f6162c53f659f65d00619fe31f14556a6e9f8752ccc4a41bd177ffcf3d6130"
+checksum = "548d977b6da32fa1d1fda2876453da1e7df63ad0304c8b3dae4dbe7b96f39b78"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
 "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.4.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d135dd939bad62d7490b0002602d35b358dce5fd9233a709d3c1ef467d4bde6"
+checksum = "3d4fc12a85bcf441cfe44344c4b72d58493178ce635338a3f3b78943aceb258e"
 dependencies = [
 "defmt-parser",
 "proc-macro-error2",
@@ -233,18 +217,28 @@ dependencies = [

 [[package]]
 name = "defmt-parser"
-version = "0.4.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3983b127f13995e68c1e29071e5d115cd96f215ccb5e6812e3728cd6f92653b3"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
 dependencies = [
 "thiserror",
 ]

 [[package]]
-name = "defmt-test"
-version = "0.3.2"
+name = "defmt-rtt"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290966e8c38f94b11884877242de876280d0eab934900e9642d58868e77c5df1"
+checksum = "b2cac3b8a5644a9e02b75085ebad3b6deafdbdbdec04bb25086523828aa4dfd1"
+dependencies = [
+ "critical-section",
+ "defmt",
+]
+
+[[package]]
+name = "defmt-test"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24076cc7203c365e7febfcec15d6667a9ef780bd2c5fd3b2a197400df78f299b"
 dependencies = [
 "cortex-m-rt",
 "cortex-m-semihosting",
@@ -254,9 +248,9 @@ dependencies = [

 [[package]]
 name = "defmt-test-macros"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "984bc6eca246389726ac2826acc2488ca0fe5fcd6b8d9b48797021951d76a125"
+checksum = "fe5520fd36862f281c026abeaab153ebbc001717c29a9b8e5ba9704d8f3a879d"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -286,12 +280,140 @@ dependencies = [
 ]

 [[package]]
-name = "embedded-dma"
+name = "document-features"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
+dependencies = [
+ "litrs",
+]
+
+[[package]]
+name = "embassy-embedded-hal"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "554e3e840696f54b4c9afcf28a0f24da431c927f4151040020416e7393d6d0d8"
+dependencies = [
+ "embassy-futures",
+ "embassy-hal-internal",
+ "embassy-sync",
+ "embedded-hal 0.2.7",
+ "embedded-hal 1.0.0",
+ "embedded-hal-async",
+ "embedded-storage",
+ "embedded-storage-async",
+ "nb 1.1.0",
+]
+
+[[package]]
+name = "embassy-futures"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc2d050bdc5c21e0862a89256ed8029ae6c290a93aecefc73084b3002cdebb01"
+
+[[package]]
+name = "embassy-hal-internal"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95285007a91b619dc9f26ea8f55452aa6c60f7115a4edc05085cd2bd3127cd7a"
+dependencies = [
+ "cortex-m",
+ "critical-section",
+ "num-traits",
+]
+
+[[package]]
+name = "embassy-net-driver"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "994f7e5b5cb23521c22304927195f236813053eb9c065dd2226a32ba64695446"
+checksum = "524eb3c489760508f71360112bca70f6e53173e6fe48fc5f0efd0f5ab217751d"
+
+[[package]]
+name = "embassy-stm32"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d972eab325cc96afee98f80a91ca6b00249b6356dc0fdbff68b70c200df9fae"
 dependencies = [
- "stable_deref_trait",
+ "aligned",
+ "bit_field",
+ "bitflags 2.9.4",
+ "block-device-driver",
+ "cfg-if",
+ "cortex-m",
+ "cortex-m-rt",
+ "critical-section",
+ "document-features",
+ "embassy-embedded-hal",
+ "embassy-futures",
+ "embassy-hal-internal",
+ "embassy-net-driver",
+ "embassy-sync",
+ "embassy-usb-driver",
+ "embassy-usb-synopsys-otg",
+ "embedded-can",
+ "embedded-hal 0.2.7",
+ "embedded-hal 1.0.0",
+ "embedded-hal-async",
+ "embedded-hal-nb",
+ "embedded-io",
+ "embedded-io-async",
+ "embedded-storage",
+ "embedded-storage-async",
+ "futures-util",
+ "nb 1.1.0",
+ "proc-macro2",
+ "quote",
+ "rand_core 0.6.4",
+ "rand_core 0.9.3",
+ "sdio-host",
+ "static_assertions",
+ "stm32-fmc",
+ "stm32-metapac",
+ "vcell",
+ "volatile-register",
+]
+
+[[package]]
+name = "embassy-sync"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73974a3edbd0bd286759b3d483540f0ebef705919a5f56f4fc7709066f71689b"
+dependencies = [
+ "cfg-if",
+ "critical-section",
+ "embedded-io-async",
+ "futures-core",
+ "futures-sink",
+ "heapless 0.8.0",
+]
+
+[[package]]
+name = "embassy-usb-driver"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17119855ccc2d1f7470a39756b12068454ae27a3eabb037d940b5c03d9c77b7a"
+dependencies = [
+ "embedded-io-async",
+]
+
+[[package]]
+name = "embassy-usb-synopsys-otg"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "288751f8eaa44a5cf2613f13cee0ca8e06e6638cb96e897e6834702c79084b23"
+dependencies = [
+ "critical-section",
+ "embassy-sync",
+ "embassy-usb-driver",
+]
+
+[[package]]
+name = "embedded-can"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9d2e857f87ac832df68fa498d18ddc679175cf3d2e4aa893988e5601baf9438"
+dependencies = [
+ "nb 1.1.0",
 ]

 [[package]]
@@ -320,12 +442,43 @@ dependencies = [
 ]

 [[package]]
-name = "embedded-time"
-version = "0.12.1"
+name = "embedded-hal-nb"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a4b4d10ac48d08bfe3db7688c402baadb244721f30a77ce360bd24c3dffe58"
+checksum = "fba4268c14288c828995299e59b12babdbe170f6c6d73731af1b4648142e8605"
 dependencies = [
- "num",
+ "embedded-hal 1.0.0",
+ "nb 1.1.0",
+]
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
+[[package]]
+name = "embedded-io-async"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff09972d4073aa8c299395be75161d582e7629cd663171d62af73c8d50dba3f"
+dependencies = [
+ "embedded-io",
+]
+
+[[package]]
+name = "embedded-storage"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21dea9854beb860f3062d10228ce9b976da520a73474aed3171ec276bc0c032"
+
+[[package]]
+name = "embedded-storage-async"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1763775e2323b7d5f0aa6090657f5e21cfa02ede71f5dc40eead06d64dcd15cc"
+dependencies = [
+ "embedded-storage",
 ]

 [[package]]
@@ -376,6 +529,12 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"

+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
 [[package]]
 name = "futures-task"
 version = "0.3.31"
@@ -400,25 +559,6 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a"

-[[package]]
-name = "generic-array"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "667f6ea017b297ec65b8a108c6e9ad6879460721fb3b6b23abf690970147fc28"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -444,6 +584,16 @@ dependencies = [
 "stable_deref_trait",
 ]

+[[package]]
+name = "heapless"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1edcd5a338e64688fbdcb7531a846cfd3476a54784dcb918a0844682bc7ada5"
+dependencies = [
+ "hash32",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -461,24 +611,10 @@ dependencies = [
 ]

 [[package]]
-name = "lsm303dlhc"
-version = "0.2.0"
+name = "litrs"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5d1a5c290951321d1b0d4a40edd828537de9889134a0e67c5146542ae57706"
-dependencies = [
- "cast",
- "embedded-hal 0.2.7",
- "generic-array 0.11.2",
-]
-
-[[package]]
-name = "micromath"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc4010833aea396656c2f91ee704d51a6f1329ec2ab56ffd00bfd56f7481ea94"
-dependencies = [
- "generic-array 0.14.7",
-]
+checksum = "f5e54036fe321fd421e10d732f155734c4e4afd610dd556d9a82833ab3ee0bed"

 [[package]]
 name = "nb"
@@ -495,59 +631,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d5439c4ad607c3c23abf66de8c8bf57ba8adcd1f129e699851a6e43935d339d"

-[[package]]
-name = "num"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b7a8e9be5e039e2ff869df49155f1c06bd01ade2117ec783e56ab0932b67a8f"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-iter",
- "num-rational",
- "num-traits",
-]
-
-[[package]]
-name = "num-complex"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747d632c0c558b87dbabbe6a82f3b4ae03720d0646ac5b7b4dae89394be5f2c5"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -579,9 +662,9 @@ dependencies = [

 [[package]]
 name = "panic-probe"
-version = "0.3.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4047d9235d1423d66cc97da7d07eddb54d4f154d6c13805c6d0793956f4f25b0"
+checksum = "fd402d00b0fb94c5aee000029204a46884b1262e0c443f166d86d2c0747e1a1a"
 dependencies = [
 "cortex-m",
 "defmt",
@@ -652,13 +735,16 @@ dependencies = [
 ]

 [[package]]
-name = "rtcc"
-version = "0.3.2"
+name = "rand_core"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95973c3a0274adc4f3c5b70d2b5b85618d6de9559a6737d3293ecae9a2fc0839"
-dependencies = [
- "chrono",
-]
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"

 [[package]]
 name = "rtic"
@@ -735,42 +821,27 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "semver 0.9.0",
-]
-
-[[package]]
-name = "rustc_version"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
-dependencies = [
- "semver 1.0.25",
+ "semver",
 ]

 [[package]]
 name = "satrs"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "866fcae3b683ccc37b5ad77982483a0ee01d5dc408dea5aad2117ad404b60fe1"
+version = "0.3.0-alpha.2"
 dependencies = [
- "cobs 0.2.3",
- "crc",
+ "cobs",
 "defmt",
 "delegate",
 "derive-new",
- "num-traits",
 "num_enum",
 "paste",
 "satrs-shared",
- "smallvec",
 "spacepackets",
+ "thiserror",
 ]

 [[package]]
 name = "satrs-shared"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6042477018c2d43fffccaaa5099bc299a58485139b4d31c5b276889311e474f1"
+version = "0.2.3"
 dependencies = [
 "spacepackets",
 ]
@@ -779,24 +850,31 @@ dependencies = [
 name = "satrs-stm32f3-disco-rtic"
 version = "0.1.0"
 dependencies = [
- "cobs 0.3.0",
+ "cobs",
 "cortex-m",
 "cortex-m-rt",
 "cortex-m-semihosting",
 "defmt",
- "defmt-brtt",
+ "defmt-rtt",
 "defmt-test",
- "embedded-hal 0.2.7",
+ "embassy-stm32",
+ "embedded-hal 1.0.0",
 "enumset",
- "heapless",
+ "heapless 0.9.1",
 "panic-probe",
 "rtic",
 "rtic-monotonics",
 "satrs",
- "stm32f3-discovery",
- "stm32f3xx-hal",
+ "spacepackets",
+ "static_cell",
 ]

+[[package]]
+name = "sdio-host"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b328e2cb950eeccd55b7f55c3a963691455dcd044cfb5354f0c5e68d2c2d6ee2"
+
 [[package]]
 name = "semver"
 version = "0.9.0"
@@ -806,41 +884,25 @@ dependencies = [
 "semver-parser",
 ]

-[[package]]
-name = "semver"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
-
 [[package]]
 name = "semver-parser"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"

-[[package]]
-name = "slice-group-by"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
-
-[[package]]
-name = "smallvec"
-version = "1.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
-
 [[package]]
 name = "spacepackets"
-version = "0.11.2"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e85574d113a06312010c0ba51aadccd4ba2806231ebe9a49fc6473d0534d8696"
+checksum = "95ca19d2a251259686f6fffb094a8e32824098f387cd613ae81bfe4216524d02"
 dependencies = [
 "crc",
 "defmt",
 "delegate",
 "num-traits",
 "num_enum",
+ "paste",
+ "thiserror",
 "zerocopy",
 ]

@@ -851,74 +913,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"

 [[package]]
-name = "stm32-usbd"
-version = "0.6.0"
+name = "static_assertions"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6c94998f166d66b210a164648a0b7866428d8f1e0740bf8a4c5edd89d4750c1"
-dependencies = [
- "cortex-m",
- "usb-device",
- "vcell",
-]
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

 [[package]]
-name = "stm32f3"
-version = "0.15.1"
+name = "static_cell"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b28b37228ef3fa47956af38c6abd756e912f244c1657f14e66d42fc8d74ea96f"
+checksum = "0530892bb4fa575ee0da4b86f86c667132a94b74bb72160f58ee5a4afec74c23"
 dependencies = [
- "bare-metal 1.0.0",
- "cortex-m",
- "cortex-m-rt",
- "vcell",
+ "portable-atomic",
 ]

 [[package]]
-name = "stm32f3-discovery"
-version = "0.8.0-alpha.0"
-source = "git+https://github.com/robamu/stm32f3-discovery?branch=complete-dma-update-hal#5ccacae07ceff02d7d3649df67a6a0ba2a144752"
-dependencies = [
- "accelerometer",
- "cortex-m",
- "cortex-m-rt",
- "lsm303dlhc",
- "stm32f3xx-hal",
- "switch-hal",
-]
-
-[[package]]
-name = "stm32f3xx-hal"
-version = "0.11.0-alpha.0"
-source = "git+https://github.com/robamu/stm32f3xx-hal?branch=complete-dma-update#04fc76b7912649c84b57bd0ab803ea3ccf2aadae"
-dependencies = [
- "bxcan",
- "cfg-if",
- "cortex-m",
- "cortex-m-rt",
- "critical-section",
- "embedded-dma",
- "embedded-hal 0.2.7",
- "embedded-time",
- "enumset",
- "nb 1.1.0",
- "num-traits",
- "paste",
- "rtcc",
- "slice-group-by",
- "stm32-usbd",
- "stm32f3",
- "void",
-]
-
-[[package]]
-name = "switch-hal"
-version = "0.4.0"
+name = "stm32-fmc"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90a4adc8cbd1726249b161898e48e0f3f1ce74d34dc784cbbc98fba4ed283fbf"
+checksum = "c7f0639399e2307c2446c54d91d4f1596343a1e1d5cab605b9cce11d0ab3858c"
 dependencies = [
 "embedded-hal 0.2.7",
 ]

+[[package]]
+name = "stm32-metapac"
+version = "18.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fd8ec3a292a0d9fc4798416a61b21da5ae50341b2e7b8d12e662bf305366097"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -961,36 +988,18 @@ dependencies = [
 "syn 2.0.96",
 ]

-[[package]]
-name = "typenum"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"

-[[package]]
-name = "usb-device"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f6cc3adc849b5292b4075fc0d5fdcf2f24866e88e336dd27a8943090a520508"
-
 [[package]]
 name = "vcell"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002"

-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
 [[package]]
 name = "void"
 version = "1.0.2"
@@ -1008,19 +1017,18 @@ dependencies = [

 [[package]]
 name = "zerocopy"
-version = "0.7.35"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
 dependencies = [
- "byteorder",
 "zerocopy-derive",
 ]

 [[package]]
 name = "zerocopy-derive"
-version = "0.7.35"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/embedded-examples/stm32f3-disco-rtic/Cargo.toml
+++ b/embedded-examples/stm32f3-disco-rtic/Cargo.toml
@@ -9,13 +9,16 @@ default-run = "satrs-stm32f3-disco-rtic"
 [dependencies]
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-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"
+defmt = "1"
+defmt-rtt = { version = "1" }
+panic-probe = { version = "1", features = ["print-defmt"] }
+embedded-hal = "1"
 cortex-m-semihosting = "0.5.0"
+embassy-stm32 = { version = "0.4", features = ["stm32f303vc", "unstable-pac"] }
 enumset = "1"
-heapless = "0.8"
+heapless = "0.9"
+spacepackets = { version = "0.15", default-features = false, features = ["defmt"] }
+static_cell = "2"

 [dependencies.rtic]
 version = "2"
@@ -26,32 +29,32 @@ version = "2"
 features = ["cortex-m-systick"]

 [dependencies.cobs]
-version = "0.3"
+version = "0.4"
 default-features = false

-[dependencies.stm32f3xx-hal]
-git = "https://github.com/robamu/stm32f3xx-hal"
-version = "0.11.0-alpha.0"
-features = ["stm32f303xc", "rt", "enumset"]
-branch = "complete-dma-update"
+# [dependencies.stm32f3xx-hal]
+# git = "https://github.com/robamu/stm32f3xx-hal"
+# version = "0.11.0-alpha.0"
+# features = ["stm32f303xc", "rt", "enumset"]
+# branch = "complete-dma-update"
 # Can be used in workspace to develop and update HAL
 # path = "../stm32f3xx-hal"

-[dependencies.stm32f3-discovery]
-git = "https://github.com/robamu/stm32f3-discovery"
-version = "0.8.0-alpha.0"
-branch = "complete-dma-update-hal"
+# [dependencies.stm32f3-discovery]
+# git = "https://github.com/robamu/stm32f3-discovery"
+# version = "0.8.0-alpha.0"
+# branch = "complete-dma-update-hal"
 # Can be used in workspace to develop and update BSP
 # path = "../stm32f3-discovery"

 [dependencies.satrs]
-# path = "satrs"
-version = "0.2"
+# version = "0.2"
+path = "../../satrs"
 default-features = false
 features = ["defmt"]

 [dev-dependencies]
-defmt-test = "0.3"
+defmt-test = "0.4"

 # cargo test
 [profile.test]
--- a/embedded-examples/stm32f3-disco-rtic/src/bin/blinky.rs
+++ b/embedded-examples/stm32f3-disco-rtic/src/bin/blinky.rs
@@ -1,76 +1,61 @@
-#![no_std]
 #![no_main]
-use satrs_stm32f3_disco_rtic as _;
+#![no_std]

-use stm32f3_discovery::leds::Leds;
-use stm32f3_discovery::stm32f3xx_hal::delay::Delay;
-use stm32f3_discovery::stm32f3xx_hal::{pac, prelude::*};
-use stm32f3_discovery::switch_hal::{OutputSwitch, ToggleableOutputSwitch};
+use panic_probe as _;
+use rtic::app;

-#[cortex_m_rt::entry]
-fn main() -> ! {
-    defmt::println!("STM32F3 Discovery Blinky");
-    let dp = pac::Peripherals::take().unwrap();
-    let mut rcc = dp.RCC.constrain();
-    let cp = cortex_m::Peripherals::take().unwrap();
-    let mut flash = dp.FLASH.constrain();
-    let clocks = rcc.cfgr.freeze(&mut flash.acr);
-    let mut delay = Delay::new(cp.SYST, clocks);
+#[app(device = embassy_stm32)]
+mod app {
+    use rtic_monotonics::fugit::ExtU32;
+    use rtic_monotonics::Monotonic as _;
+    use satrs_stm32f3_disco_rtic::{Direction, LedPinSet, Leds};

-    let mut gpioe = dp.GPIOE.split(&mut rcc.ahb);
-    let mut leds = Leds::new(
-        gpioe.pe8,
-        gpioe.pe9,
-        gpioe.pe10,
-        gpioe.pe11,
-        gpioe.pe12,
-        gpioe.pe13,
-        gpioe.pe14,
-        gpioe.pe15,
-        &mut gpioe.moder,
-        &mut gpioe.otyper,
-    );
-    let delay_ms = 200u16;
-    loop {
-        leds.ld3_n.toggle().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld3_n.toggle().ok();
-        delay.delay_ms(delay_ms);
+    rtic_monotonics::systick_monotonic!(Mono, 1000);

-        //explicit on/off
-        leds.ld4_nw.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld4_nw.off().ok();
-        delay.delay_ms(delay_ms);
+    #[shared]
+    struct Shared {}

-        leds.ld5_ne.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld5_ne.off().ok();
-        delay.delay_ms(delay_ms);
+    #[local]
+    struct Local {
+        leds: Leds,
+        current_dir: Direction,
+    }

-        leds.ld6_w.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld6_w.off().ok();
-        delay.delay_ms(delay_ms);
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
+        let p = embassy_stm32::init(Default::default());

-        leds.ld7_e.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld7_e.off().ok();
-        delay.delay_ms(delay_ms);
+        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery using RTICv2");

-        leds.ld8_sw.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld8_sw.off().ok();
-        delay.delay_ms(delay_ms);
+        let led_pin_set = LedPinSet {
+            pin_n: p.PE8,
+            pin_ne: p.PE9,
+            pin_e: p.PE10,
+            pin_se: p.PE11,
+            pin_s: p.PE12,
+            pin_sw: p.PE13,
+            pin_w: p.PE14,
+            pin_nw: p.PE15,
+        };
+        let leds = Leds::new(led_pin_set);

-        leds.ld9_se.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld9_se.off().ok();
-        delay.delay_ms(delay_ms);
+        // Initialize the systick interrupt & obtain the token to prove that we did
+        Mono::start(cx.core.SYST, 8_000_000);
+        blinky::spawn().expect("failed to spawn blinky task");
+        (
+            Shared {},
+            Local {
+                leds,
+                current_dir: Direction::North,
+            },
+        )
+    }

-        leds.ld10_s.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld10_s.off().ok();
-        delay.delay_ms(delay_ms);
+    #[task(local = [leds, current_dir])]
+    async fn blinky(cx: blinky::Context) {
+        loop {
+            cx.local.leds.blink_next(cx.local.current_dir);
+            Mono::delay(200.millis()).await;
+        }
    }
 }
--- a/embedded-examples/stm32f3-disco-rtic/src/lib.rs
+++ b/embedded-examples/stm32f3-disco-rtic/src/lib.rs
@@ -3,12 +3,147 @@

 use cortex_m_semihosting::debug;

-use defmt_brtt as _; // global logger
-
-use stm32f3xx_hal as _; // memory layout
+use defmt_rtt as _; // global logger

 use panic_probe as _;

+use embassy_stm32::gpio::Output;
+
+#[derive(defmt::Format, PartialEq, Eq, Clone, Copy)]
+pub enum Direction {
+    North,
+    NorthEast,
+    East,
+    SouthEast,
+    South,
+    SouthWest,
+    West,
+    NorthWest,
+}
+
+impl Direction {
+    pub fn switch_to_next(&mut self) -> (Self, Self) {
+        let curr = *self;
+        *self = match self {
+            Direction::North => Direction::NorthEast,
+            Direction::NorthEast => Direction::East,
+            Direction::East => Direction::SouthEast,
+            Direction::SouthEast => Direction::South,
+            Direction::South => Direction::SouthWest,
+            Direction::SouthWest => Direction::West,
+            Direction::West => Direction::NorthWest,
+            Direction::NorthWest => Direction::North,
+        };
+        (curr, *self)
+    }
+}
+
+pub struct Leds {
+    pub north: Output<'static>,
+    pub north_east: Output<'static>,
+    pub east: Output<'static>,
+    pub south_east: Output<'static>,
+    pub south: Output<'static>,
+    pub south_west: Output<'static>,
+    pub west: Output<'static>,
+    pub north_west: Output<'static>,
+}
+
+impl Leds {
+    pub fn blink_next(&mut self, current_dir: &mut Direction) {
+        let (prev, curr) = current_dir.switch_to_next();
+        self.set_dir_low(prev);
+        self.set_dir_high(curr);
+    }
+
+    pub fn set_dir(&mut self, dir: Direction, level: embassy_stm32::gpio::Level) {
+        match dir {
+            Direction::North => self.north.set_level(level),
+            Direction::NorthEast => self.north_east.set_level(level),
+            Direction::East => self.east.set_level(level),
+            Direction::SouthEast => self.south_east.set_level(level),
+            Direction::South => self.south.set_level(level),
+            Direction::SouthWest => self.south_west.set_level(level),
+            Direction::West => self.west.set_level(level),
+            Direction::NorthWest => self.north_west.set_level(level),
+        }
+    }
+
+    pub fn set_dir_low(&mut self, dir: Direction) {
+        self.set_dir(dir, embassy_stm32::gpio::Level::Low);
+    }
+
+    pub fn set_dir_high(&mut self, dir: Direction) {
+        self.set_dir(dir, embassy_stm32::gpio::Level::High);
+    }
+}
+
+pub struct LedPinSet {
+    pub pin_n: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE8>,
+    pub pin_ne: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE9>,
+    pub pin_e: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE10>,
+    pub pin_se: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE11>,
+    pub pin_s: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE12>,
+    pub pin_sw: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE13>,
+    pub pin_w: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE14>,
+    pub pin_nw: embassy_stm32::Peri<'static, embassy_stm32::peripherals::PE15>,
+}
+
+impl Leds {
+    pub fn new(pin_set: LedPinSet) -> Self {
+        let led_n = Output::new(
+            pin_set.pin_n,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_ne = Output::new(
+            pin_set.pin_ne,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_e = Output::new(
+            pin_set.pin_e,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_se = Output::new(
+            pin_set.pin_se,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_s = Output::new(
+            pin_set.pin_s,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_sw = Output::new(
+            pin_set.pin_sw,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_w = Output::new(
+            pin_set.pin_w,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        let led_nw = Output::new(
+            pin_set.pin_nw,
+            embassy_stm32::gpio::Level::Low,
+            embassy_stm32::gpio::Speed::Medium,
+        );
+        Self {
+            north: led_n,
+            north_east: led_ne,
+            east: led_e,
+            south_east: led_se,
+            south: led_s,
+            south_west: led_sw,
+            west: led_w,
+            north_west: led_nw,
+        }
+    }
+}
+
 // 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]
--- a/embedded-examples/stm32f3-disco-rtic/src/main.rs
+++ b/embedded-examples/stm32f3-disco-rtic/src/main.rs
@@ -1,8 +1,6 @@
 #![no_std]
 #![no_main]
-use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReportCreator, VerificationToken,
-};
+use satrs::pus::verification::{FailParams, VerificationReportCreator};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use satrs::spacepackets::ecss::EcssEnumU16;
@@ -13,16 +11,12 @@ use satrs_stm32f3_disco_rtic as _;

 use rtic::app;

-use heapless::{mpmc::Q8, Vec};
+use heapless::Vec;
 #[allow(unused_imports)]
 use rtic_monotonics::fugit::{MillisDurationU32, TimerInstantU32};
 use rtic_monotonics::systick::prelude::*;
-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 spacepackets::seq_count::SequenceCountProvider;

 const UART_BAUD: u32 = 115200;
 const DEFAULT_BLINK_FREQ_MS: u32 = 1000;
@@ -30,33 +24,24 @@ 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 InstantFugit = TimerInstantU32<1000>;
-type TxDmaTransferType = SerialDmaTx<&'static [u8], dma1::C7, TxType>;
-type RxDmaTransferType = SerialDmaRx<&'static mut [u8], dma1::C6, RxType>;
+pub const PUS_APID: u16 = 0x02;

 // This is the predictable maximum overhead of the COBS encoding scheme.
 // It is simply the maximum packet lenght dividied by 254 rounded up.
-const COBS_TC_OVERHEAD: usize = (MAX_TC_LEN + 254 - 1) / 254;
-const COBS_TM_OVERHEAD: usize = (MAX_TM_LEN + 254 - 1) / 254;
+const COBS_TC_OVERHEAD: usize = cobs::max_encoding_overhead(MAX_TC_LEN);
+const COBS_TM_OVERHEAD: usize = cobs::max_encoding_overhead(MAX_TM_LEN);

 const TC_BUF_LEN: usize = MAX_TC_LEN + COBS_TC_OVERHEAD;
 const TM_BUF_LEN: usize = MAX_TC_LEN + COBS_TM_OVERHEAD;

-// This is a static buffer which should ONLY (!) be used as the TX DMA
-// transfer buffer.
-static mut DMA_TX_BUF: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN];
-// This is a static buffer which should ONLY (!) be used as the RX DMA
-// transfer buffer.
-static mut DMA_RX_BUF: [u8; TC_BUF_LEN] = [0; TC_BUF_LEN];
+const TC_DMA_BUF_LEN: usize = 512;

-type TmPacket = Vec<u8, MAX_TM_LEN>;
-type TcPacket = Vec<u8, MAX_TC_LEN>;
+type TmPacket = heapless::Vec<u8, MAX_TM_LEN>;
+type TcPacket = heapless::Vec<u8, MAX_TC_LEN>;

-static TM_REQUESTS: Q8<TmPacket> = Q8::new();
+static TM_REQUESTS: static_cell::ConstStaticCell<heapless::spsc::Queue<TmPacket, 8>> =
+    static_cell::ConstStaticCell::new(heapless::spsc::Queue::new());

 use core::sync::atomic::{AtomicU16, Ordering};

@@ -74,7 +59,10 @@ impl SeqCountProviderAtomicRef {
    }
 }

-impl SequenceCountProviderCore<u16> for SeqCountProviderAtomicRef {
+impl SequenceCountProvider for SeqCountProviderAtomicRef {
+    type Raw = u16;
+    const MAX_BIT_WIDTH: usize = 16;
+
    fn get(&self) -> u16 {
        self.atomic.load(self.ordering)
    }
@@ -92,8 +80,8 @@ static SEQ_COUNT_PROVIDER: SeqCountProviderAtomicRef =
    SeqCountProviderAtomicRef::new(Ordering::Relaxed);

 pub struct TxIdle {
-    tx: TxType,
-    dma_channel: dma1::C7,
+    //tx: TxType,
+    //dma_channel: dma1::C7,
 }

 #[derive(Debug, defmt::Format)]
@@ -108,49 +96,8 @@ impl From<ByteConversionError> for TmSendError {
    }
 }

-fn send_tm(tm_creator: PusTmCreator) -> Result<(), TmSendError> {
-    if tm_creator.len_written() > MAX_TM_LEN {
-        return Err(ByteConversionError::ToSliceTooSmall {
-            expected: tm_creator.len_written(),
-            found: MAX_TM_LEN,
-        }
-        .into());
-    }
-    let mut tm_vec = TmPacket::new();
-    tm_vec
-        .resize(tm_creator.len_written(), 0)
-        .expect("vec resize failed");
-    tm_creator.write_to_bytes(tm_vec.as_mut_slice())?;
-    defmt::info!(
-        "Sending TM[{},{}] with size {}",
-        tm_creator.service(),
-        tm_creator.subservice(),
-        tm_creator.len_written()
-    );
-    TM_REQUESTS
-        .enqueue(tm_vec)
-        .map_err(|_| TmSendError::Queue)?;
-    Ok(())
-}
-
-fn handle_tm_send_error(error: TmSendError) {
-    defmt::warn!("sending tm failed with error {}", error);
-}
-
-pub enum UartTxState {
-    // Wrapped in an option because we need an owned type later.
-    Idle(Option<TxIdle>),
-    // Same as above
-    Transmitting(Option<TxDmaTransferType>),
-}
-
-pub struct UartTxShared {
-    last_completed: Option<InstantFugit>,
-    state: UartTxState,
-}
-
 pub struct RequestWithToken {
-    token: VerificationToken<TcStateAccepted>,
+    request_id: satrs::pus::verification::RequestId,
    request: Request,
 }

@@ -168,147 +115,69 @@ pub enum RequestError {
    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)]
+#[app(device = embassy_stm32)]
 mod app {
    use super::*;
-    use core::slice::Iter;
-    use satrs::pus::verification::{TcStateStarted, VerificationReportCreator};
+    use satrs::pus::verification::VerificationReportCreator;
    use satrs::spacepackets::{ecss::tc::PusTcReader, time::cds::P_FIELD_BASE};
-    #[allow(unused_imports)]
-    use stm32f3_discovery::leds::Direction;
-    use stm32f3_discovery::leds::Leds;
-    use stm32f3xx_hal::prelude::*;
-
-    use stm32f3_discovery::switch_hal::OutputSwitch;
-    use stm32f3xx_hal::Switch;
-    #[allow(dead_code)]
-    type SerialType = Serial<USART2, (PA2<AF7<PushPull>>, PA3<AF7<PushPull>>)>;
+    use satrs_stm32f3_disco_rtic::LedPinSet;

    systick_monotonic!(Mono, 1000);

+    embassy_stm32::bind_interrupts!(struct Irqs {
+        USART2 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART2>;
+    });
+
    #[shared]
    struct Shared {
        blink_freq: MillisDurationU32,
-        tx_shared: UartTxShared,
-        rx_transfer: Option<RxDmaTransferType>,
    }

    #[local]
    struct Local {
        verif_reporter: VerificationReportCreator,
-        leds: Leds,
-        last_dir: Direction,
-        curr_dir: Iter<'static, Direction>,
+        leds: satrs_stm32f3_disco_rtic::Leds,
+        current_dir: satrs_stm32f3_disco_rtic::Direction,
+        tm_prod: heapless::spsc::Producer<'static, TmPacket>,
+        tm_cons: heapless::spsc::Consumer<'static, TmPacket>,
+        tx: embassy_stm32::usart::UartTx<'static, embassy_stm32::mode::Async>,
+        rx: embassy_stm32::usart::RingBufferedUartRx<'static>,
    }

    #[init]
    fn init(cx: init::Context) -> (Shared, Local) {
-        let mut rcc = cx.device.RCC.constrain();
+        static DMA_BUF: static_cell::ConstStaticCell<[u8; TC_DMA_BUF_LEN]> = static_cell::ConstStaticCell::new([0; TC_DMA_BUF_LEN]);
+
+        let p = embassy_stm32::init(Default::default());

        // Initialize the systick interrupt & obtain the token to prove that we did
        Mono::start(cx.core.SYST, 8_000_000);

-        let mut flash = cx.device.FLASH.constrain();
-        let clocks = rcc
-            .cfgr
-            .use_hse(8.MHz())
-            .sysclk(8.MHz())
-            .pclk1(8.MHz())
-            .freeze(&mut flash.acr);
+        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery with RTICv2");
+        let led_pin_set = LedPinSet {
+            pin_n: p.PE8,
+            pin_ne: p.PE9,
+            pin_e: p.PE10,
+            pin_se: p.PE11,
+            pin_s: p.PE12,
+            pin_sw: p.PE13,
+            pin_w: p.PE14,
+            pin_nw: p.PE15,
+        };
+        let leds = satrs_stm32f3_disco_rtic::Leds::new(led_pin_set);

-        // Set up monotonic timer.
-        //let mono_timer = MonoTimer::new(cx.core.DWT, clocks, &mut cx.core.DCB);
+        let config = embassy_stm32::usart::Config::default();
+        let uart = embassy_stm32::usart::Uart::new(
+            p.USART2, p.PA3, p.PA2, Irqs, p.DMA1_CH7, p.DMA1_CH6, config,
+        )
+        .unwrap();

-        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery");
-        let mut gpioe = cx.device.GPIOE.split(&mut rcc.ahb);
-
-        let leds = Leds::new(
-            gpioe.pe8,
-            gpioe.pe9,
-            gpioe.pe10,
-            gpioe.pe11,
-            gpioe.pe12,
-            gpioe.pe13,
-            gpioe.pe14,
-            gpioe.pe15,
-            &mut gpioe.moder,
-            &mut gpioe.otyper,
-        );
-        let mut gpioa = cx.device.GPIOA.split(&mut rcc.ahb);
+        let (tx, rx) = uart.split();
+        let tm_queue = TM_REQUESTS.take();
+        let (tm_prod, tm_cons) = tm_queue.split();
+        //let mut gpioa = cx.device.GPIOA.split(&mut rcc.ahb);
        // USART2 pins
+        /*
        let mut pins = (
            // TX pin: PA2
            gpioa
@@ -319,29 +188,32 @@ mod app {
                .pa3
                .into_af_push_pull(&mut gpioa.moder, &mut gpioa.otyper, &mut gpioa.afrl),
        );
-        pins.1.internal_pull_up(&mut gpioa.pupdr, true);
-        let mut usart2 = Serial::new(
-            cx.device.USART2,
-            pins,
-            UART_BAUD.Bd(),
-            clocks,
-            &mut rcc.apb1,
-        );
-        usart2.configure_rx_interrupt(RxEvent::Idle, Switch::On);
-        // This interrupt is enabled to re-schedule new transfers in the interrupt handler immediately.
-        usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Switch::On);
+        */
+        //pins.1.internal_pull_up(&mut gpioa.pupdr, true);
+        /*
+                let mut usart2 = Serial::new(
+                    cx.device.USART2,
+                    pins,
+                    UART_BAUD.Bd(),
+                    clocks,
+                    &mut rcc.apb1,
+                );
+                usart2.configure_rx_interrupt(RxEvent::Idle, Switch::On);
+                // This interrupt is enabled to re-schedule new transfers in the interrupt handler immediately.
+                usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Switch::On);
+        */

-        let dma1 = cx.device.DMA1.split(&mut rcc.ahb);
-        let (mut tx_serial, mut rx_serial) = usart2.split();
+        //let dma1 = cx.device.DMA1.split(&mut rcc.ahb);
+        //let (mut tx_serial, mut rx_serial) = usart2.split();

        // This interrupt is immediately triggered, clear it. It will only be reset
        // by the hardware when data is received on RX (RXNE event)
-        rx_serial.clear_event(RxEvent::Idle);
+        //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);
+        //tx_serial.clear_event(TxEvent::TransmissionComplete);
+        //let rx_transfer = rx_serial.read_exact(unsafe { DMA_RX_BUF.as_mut_slice() }, dma1.ch6);
        defmt::info!("Spawning tasks");
-        blink::spawn().unwrap();
+        blinky::spawn().unwrap();
        serial_tx_handler::spawn().unwrap();

        let verif_reporter = VerificationReportCreator::new(PUS_APID).unwrap();
@@ -349,118 +221,49 @@ mod app {
        (
            Shared {
                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(),
+                tm_prod,
+                tm_cons,
+                tx,
+                rx: rx.into_ring_buffered(DMA_BUF.take()),
+                current_dir: satrs_stm32f3_disco_rtic::Direction::North,
            },
        )
    }

-    #[task(local = [leds, curr_dir, last_dir], shared=[blink_freq])]
-    async fn blink(mut cx: blink::Context) {
-        let blink::LocalResources {
-            leds,
-            curr_dir,
-            last_dir,
-            ..
-        } = cx.local;
-        let mut toggle_leds = |dir: &Direction| {
-            let last_led = leds.for_direction(*last_dir);
-            last_led.off().ok();
-            let led = leds.for_direction(*dir);
-            led.on().ok();
-            *last_dir = *dir;
-        };
+    #[task(local = [leds, current_dir], shared=[blink_freq])]
+    async fn blinky(mut cx: blinky::Context) {
        loop {
-            match curr_dir.next() {
-                Some(dir) => {
-                    toggle_leds(dir);
-                }
-                None => {
-                    *curr_dir = Direction::iter();
-                    toggle_leds(curr_dir.next().unwrap());
-                }
-            }
+            cx.local.leds.blink_next(cx.local.current_dir);
            let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
            Mono::delay(current_blink_freq).await;
        }
    }

    #[task(
-        shared = [tx_shared],
+        local = [
+            tm_cons,
+            tx,
+            dma_buf: [u8; TM_BUF_LEN] = [0; TM_BUF_LEN]
+        ],
+        shared = [],
    )]
-    async fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
+    async fn serial_tx_handler(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 = (Mono::now() - last_completed).to_millis();
-                    if elapsed_ms < MIN_DELAY_BETWEEN_TX_PACKETS_MS {
-                        Mono::delay((MIN_DELAY_BETWEEN_TX_PACKETS_MS - elapsed_ms).millis()).await;
-                    }
-                }
-            } else {
-                // Check for completion after 1 ms
-                Mono::delay(1.millis()).await;
+            while let Some(vec) = cx.local.tm_cons.dequeue() {
+                cx.local.dma_buf[0] = 0;
+                let encoded_len = cobs::encode(&vec[0..vec.len()], &mut cx.local.dma_buf[1..]);
+                // Should never panic, we accounted for the overhead.
+                // Write into transfer buffer directly, no need for intermediate
+                // encoding buffer.
+                // 0 end marker
+                cx.local.dma_buf[encoded_len + 1] = 0;
+                cx.local.tx.write(&vec[0..encoded_len + 2]).await.unwrap();
                continue;
            }
-            if let Some(vec) = TM_REQUESTS.dequeue() {
-                cx.shared
-                    .tx_shared
-                    .lock(|tx_shared| match &mut tx_shared.state {
-                        UartTxState::Idle(tx) => {
-                            let encoded_len;
-                            //debug!(target: "serial_tx_handler", "bytes: {:x?}", &buf[0..len]);
-                            // Safety: We only copy the data into the TX DMA buffer in this task.
-                            // If the DMA is active, another branch will be taken.
-                            unsafe {
-                                // 0 sentinel value as start marker
-                                DMA_TX_BUF[0] = 0;
-                                encoded_len =
-                                    cobs::encode(&vec[0..vec.len()], &mut DMA_TX_BUF[1..]);
-                                // Should never panic, we accounted for the overhead.
-                                // Write into transfer buffer directly, no need for intermediate
-                                // encoding buffer.
-                                // 0 end marker
-                                DMA_TX_BUF[encoded_len + 1] = 0;
-                            }
-                            //debug!(target: "serial_tx_handler", "Sending {} bytes", encoded_len + 2);
-                            //debug!("sent: {:x?}", &mut_tx_dma_buf[0..encoded_len + 2]);
-                            let tx_idle = tx.take().unwrap();
-                            // Transfer completion and re-scheduling of new TX transfers will be done
-                            // by the IRQ handler.
-                            // SAFETY: The DMA is the exclusive writer to the DMA buffer now.
-                            let transfer = tx_idle.tx.write_all(
-                                unsafe { &DMA_TX_BUF[0..encoded_len + 2] },
-                                tx_idle.dma_channel,
-                            );
-                            tx_shared.state = UartTxState::Transmitting(Some(transfer));
-                            // The memory block is automatically returned to the pool when it is dropped.
-                        }
-                        UartTxState::Transmitting(_) => (),
-                    });
-                // Check for completion after 1 ms
-                Mono::delay(1.millis()).await;
-                continue;
-            }
-            // Nothing to do, and we are idle.
            Mono::delay(TX_HANDLER_FREQ_MS.millis()).await;
        }
    }
@@ -468,6 +271,9 @@ mod app {
    #[task(
        local = [
            verif_reporter,
+            tm_prod,
+            rx,
+            read_buf: [u8; 128] = [0; 128],
            decode_buf: [u8; MAX_TC_LEN] = [0; MAX_TC_LEN],
            src_data_buf: [u8; MAX_TM_LEN] = [0; MAX_TM_LEN],
            timestamp: [u8; 7] = [0; 7],
@@ -478,6 +284,18 @@ mod app {
        mut cx: serial_rx_handler::Context,
        received_packet: Vec<u8, MAX_TC_LEN>,
    ) {
+        let decoder = cobs::CobsDecoder::new(cx.local.decode_buf);
+        loop {
+            let read_bytes = cx.local.rx.read(cx.local.read_buf).await;
+            match decoder.push(&cx.local.read_buf[0..read_bytes]) {
+                Ok(None) => (),
+                Ok(Some(report)) => {
+
+                }
+                Err(_) => {},
+            }
+
+        }
        cx.local.timestamp[0] = P_FIELD_BASE;
        defmt::info!("Received packet with {} bytes", received_packet.len());
        let decode_buf = cx.local.decode_buf;
@@ -494,21 +312,24 @@ mod app {
            return;
        }
        let start_idx = start_idx.unwrap();
+        decoder.push(data)
        match cobs::decode(&received_packet.as_slice()[start_idx..], decode_buf) {
-            Ok(len) => {
-                defmt::info!("Decoded packet length: {}", len);
+            Ok(decode_report) => {
+                defmt::info!("Decoded packet length: {}", decode_report.frame_size());
                let pus_tc = PusTcReader::new(decode_buf);
                match pus_tc {
-                    Ok((tc, _tc_len)) => {
+                    Ok(tc) => {
                        match convert_pus_tc_to_request(
                            &tc,
                            cx.local.verif_reporter,
+                            cx.local.tm_prod,
                            cx.local.src_data_buf,
                            cx.local.timestamp,
                        ) {
                            Ok(request_with_token) => {
-                                let started_token = handle_start_verification(
-                                    request_with_token.token,
+                                handle_start_verification(
+                                    request_with_token.request_id,
+                                    cx.local.tm_prod,
                                    cx.local.verif_reporter,
                                    cx.local.src_data_buf,
                                    cx.local.timestamp,
@@ -516,7 +337,7 @@ mod app {

                                match request_with_token.request {
                                    Request::Ping => {
-                                        handle_ping_request(cx.local.timestamp);
+                                        handle_ping_request(cx.local.tm_prod, cx.local.timestamp);
                                    }
                                    Request::ChangeBlinkFrequency(new_freq_ms) => {
                                        defmt::info!("Received blink frequency change request with new frequncy {}", new_freq_ms);
@@ -527,7 +348,8 @@ mod app {
                                    }
                                }
                                handle_completion_verification(
-                                    started_token,
+                                    request_with_token.request_id,
+                                    cx.local.tm_prod,
                                    cx.local.verif_reporter,
                                    cx.local.src_data_buf,
                                    cx.local.timestamp,
@@ -550,7 +372,10 @@ mod app {
        }
    }

-    fn handle_ping_request(timestamp: &[u8]) {
+    fn handle_ping_request(
+        tm_prod: &mut heapless::spsc::Producer<'static, TmPacket>,
+        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);
@@ -561,36 +386,36 @@ mod app {
            .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() {
+        if tm_prod.enqueue(tm_packet).is_err() {
            defmt::warn!("TC queue full");
-            return;
        }
    }

    fn handle_start_verification(
-        accepted_token: VerificationToken<TcStateAccepted>,
+        request_id: satrs::pus::verification::RequestId,
+        tm_prod: &mut heapless::spsc::Producer<TmPacket>,
        verif_reporter: &mut VerificationReportCreator,
        src_data_buf: &mut [u8],
        timestamp: &[u8],
-    ) -> VerificationToken<TcStateStarted> {
-        let (tm_creator, started_token) = verif_reporter
+    ) {
+        let tm_creator = verif_reporter
            .start_success(
                src_data_buf,
-                accepted_token,
+                &request_id,
                SEQ_COUNT_PROVIDER.get(),
                0,
-                &timestamp,
+                timestamp,
            )
            .unwrap();
-        let result = send_tm(tm_creator);
+        let result = send_tm(tm_creator, tm_prod);
        if let Err(e) = result {
            handle_tm_send_error(e);
        }
-        started_token
    }

    fn handle_completion_verification(
-        started_token: VerificationToken<TcStateStarted>,
+        request_id: satrs::pus::verification::RequestId,
+        tm_prod: &mut heapless::spsc::Producer<TmPacket>,
        verif_reporter: &mut VerificationReportCreator,
        src_data_buf: &mut [u8],
        timestamp: &[u8],
@@ -599,20 +424,23 @@ mod app {
            verif_reporter
                .completion_success(
                    src_data_buf,
-                    started_token,
+                    &request_id,
                    SEQ_COUNT_PROVIDER.get(),
                    0,
                    timestamp,
                )
                .unwrap(),
+            tm_prod,
        );
        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) {
+    /*
+    #[task(binds = DMA1_CH6, shared = [])]
+    fn rx_dma_isr(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();
@@ -638,45 +466,156 @@ mod app {
                );
            }
        });
+        */
+    }
+    */
+
+    /*
+    #[task(binds = USART2_EXTI26, shared = [])]
+    fn serial_isr(mut cx: serial_isr::Context) {
+        /*
+                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, mut tx) = transfer.stop();
+                                tx.clear_event(TxEvent::TransmissionComplete);
+                                tx_shared.state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
+                                // We cache the last completed time to ensure that there is a minimum delay between consecutive
+                                // transferred packets.
+                                tx_shared.last_completed = Some(Mono::now());
+                            }
+                        }
+                    });
+                let mut tc_packet = TcPacket::new();
+                cx.shared.rx_transfer.lock(|rx_transfer| {
+                    let rx_transfer_ref = rx_transfer.as_ref().unwrap();
+                    // Received a partial packet.
+                    if rx_transfer_ref.is_event_triggered(RxEvent::Idle) {
+                        let rx_transfer_owned = rx_transfer.take().unwrap();
+                        let (buf, ch, mut rx, rx_len) = rx_transfer_owned.stop_and_return_received_bytes();
+                        // The received data is transferred to another task now to avoid any processing overhead
+                        // during the interrupt. There are multiple ways to do this, we use a stack
+                        // allocated vector to do this.
+                        tc_packet
+                            .resize(rx_len as usize, 0)
+                            .expect("vec resize failed");
+                        tc_packet[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
+                        rx.clear_event(RxEvent::Idle);
+                        serial_rx_handler::spawn(tc_packet).expect("spawning rx handler failed");
+                        *rx_transfer = Some(rx.read_exact(buf, ch));
+                    }
+                });
+        */
+    }
+    */
+}
+
+fn send_tm(
+    tm_creator: PusTmCreator,
+    tm_prod: &mut heapless::spsc::Producer<TmPacket>,
+) -> Result<(), TmSendError> {
+    if tm_creator.len_written() > MAX_TM_LEN {
+        return Err(ByteConversionError::ToSliceTooSmall {
+            expected: tm_creator.len_written(),
+            found: MAX_TM_LEN,
+        }
+        .into());
+    }
+    let mut tm_vec = TmPacket::new();
+    tm_vec
+        .resize(tm_creator.len_written(), 0)
+        .expect("vec resize failed");
+    tm_creator.write_to_bytes(tm_vec.as_mut_slice())?;
+    defmt::info!(
+        "Sending TM[{},{}] with size {}",
+        tm_creator.service(),
+        tm_creator.subservice(),
+        tm_creator.len_written()
+    );
+    tm_prod.enqueue(tm_vec).map_err(|_| TmSendError::Queue)?;
+    Ok(())
+}
+
+fn handle_tm_send_error(error: TmSendError) {
+    defmt::warn!("sending tm failed with error {}", error);
+}
+
+pub fn convert_pus_tc_to_request(
+    tc: &PusTcReader,
+    verif_reporter: &mut VerificationReportCreator,
+    tm_prod: &mut heapless::spsc::Producer<'static, TmPacket>,
+    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 request_id = verif_reporter.read_request_id(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,
+                    &request_id,
+                    SEQ_COUNT_PROVIDER.get_and_increment(),
+                    0,
+                    FailParams::new(timestamp, &EcssEnumU16::new(0), &[]),
+                )
+                .unwrap(),
+            tm_prod,
+        );
+        if let Err(e) = result {
+            handle_tm_send_error(e);
+        }
+        return Err(RequestError::InvalidApid);
+    }
+    let tm_creator = verif_reporter
+        .acceptance_success(
+            src_data_buf,
+            &request_id,
+            SEQ_COUNT_PROVIDER.get_and_increment(),
+            0,
+            timestamp,
+        )
+        .unwrap();
+
+    if let Err(e) = send_tm(tm_creator, tm_prod) {
+        handle_tm_send_error(e);
    }

-    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_shared])]
-    fn serial_isr(mut cx: serial_isr::Context) {
-        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, mut tx) = transfer.stop();
-                        tx.clear_event(TxEvent::TransmissionComplete);
-                        tx_shared.state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
-                        // We cache the last completed time to ensure that there is a minimum delay between consecutive
-                        // transferred packets.
-                        tx_shared.last_completed = Some(Mono::now());
-                    }
-                }
-            });
-        let mut tc_packet = TcPacket::new();
-        cx.shared.rx_transfer.lock(|rx_transfer| {
-            let rx_transfer_ref = rx_transfer.as_ref().unwrap();
-            // Received a partial packet.
-            if rx_transfer_ref.is_event_triggered(RxEvent::Idle) {
-                let rx_transfer_owned = rx_transfer.take().unwrap();
-                let (buf, ch, mut rx, rx_len) = rx_transfer_owned.stop_and_return_received_bytes();
-                // The received data is transferred to another task now to avoid any processing overhead
-                // during the interrupt. There are multiple ways to do this, we use a stack
-                // allocated vector to do this.
-                tc_packet
-                    .resize(rx_len as usize, 0)
-                    .expect("vec resize failed");
-                tc_packet[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
-                rx.clear_event(RxEvent::Idle);
-                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler failed");
-                *rx_transfer = Some(rx.read_exact(buf, ch));
+    if tc.service() == 17 && tc.subservice() == 1 {
+        if tc.subservice() == 1 {
+            Ok(RequestWithToken {
+                request_id,
+                request: Request::Ping,
+            })
+        } else {
+            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());
+            Ok(RequestWithToken {
+                request_id,
+                request: Request::ChangeBlinkFrequency(new_freq_ms),
+            })
+        } else {
+            Err(RequestError::InvalidSubservice)
+        }
+    } else {
+        Err(RequestError::InvalidService)
    }
 }
--- a/embedded-examples/stm32h7-nucleo-rtic/Cargo.lock
+++ b/embedded-examples/stm32h7-nucleo-rtic/Cargo.lock
--- a/embedded-examples/stm32h7-nucleo-rtic/Cargo.toml
+++ b/embedded-examples/stm32h7-nucleo-rtic/Cargo.toml
@@ -16,16 +16,17 @@ harness = false
 [dependencies]
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-defmt = "0.3"
+defmt = "1"
 defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
-panic-probe = { version = "0.3", features = ["print-defmt"] }
+panic-probe = { version = "1", features = ["print-defmt"] }
 cortex-m-semihosting = "0.5.0"
+# TODO: Replace with embassy-hal.
 stm32h7xx-hal = { version="0.16", features= ["stm32h743v", "ethernet"] }
 embedded-alloc = "0.6"
 rtic-sync = { version = "1", features = ["defmt-03"] }

 [dependencies.smoltcp]
-version = "0.11"
+version = "0.12"
 default-features = false
 features = ["medium-ethernet", "proto-ipv4", "socket-raw", "socket-dhcpv4", "socket-udp", "defmt"]

@@ -39,12 +40,12 @@ features = ["cortex-m-systick"]

 [dependencies.satrs]
 path = "../../satrs"
-version = "0.2"
+# version = "0.2"
 default-features = false
 features = ["defmt", "heapless"]

 [dev-dependencies]
-defmt-test = "0.3"
+defmt-test = "0.4"

 # cargo build/run
 [profile.dev]
--- a/experiments/satrs-gen/Cargo.toml
+++ b/experiments/satrs-gen/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "satrs-gen"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+toml = "0.8"
+heck = "0.5"
--- a/experiments/satrs-gen/components.toml
+++ b/experiments/satrs-gen/components.toml
@@ -0,0 +1,34 @@
+[apid]
+Sched = 1
+GenericPus = 2
+Acs = 3
+Cfdp = 4
+Tmtc = 5
+Eps = 6
+
+
+[ids]
+[ids.Eps]
+Pcdu = 0
+Subsystem = 1
+
+[ids.Tmtc]
+UdpServer = 0
+TcpServer = 1
+
+[ids.GenericPus]
+PusEventManagement = 0
+PusRouting = 1
+PusTest = 2
+PusAction = 3
+PusMode = 4
+PusHk = 5
+
+[ids.Sched]
+PusSched = 0
+
+[ids.Acs]
+Subsystem = 1
+Assembly = 2
+Mgm0 = 3
+Mgm1 = 4
--- a/experiments/satrs-gen/src/main.rs
+++ b/experiments/satrs-gen/src/main.rs
@@ -0,0 +1,91 @@
+use heck::{ToShoutySnakeCase, ToSnakeCase};
+use std::{
+    collections::BTreeMap,
+    fs::{self, File},
+    io::{self, Write},
+};
+
+use toml::{Value, map::Map};
+
+fn main() -> io::Result<()> {
+    // Read the configuration file
+    let config_str = fs::read_to_string("components.toml").expect("Unable to read file");
+    let config: Value = toml::from_str(&config_str).expect("Unable to parse TOML");
+
+    let mut output = File::create("../satrs-example/src/ids.rs")?;
+
+    generate_rust_code(&config, &mut output);
+    Ok(())
+}
+
+fn sort_enum_table(table_map: &Map<String, Value>) -> BTreeMap<u64, &str> {
+    // Collect entries into a BTreeMap to sort them by key
+    let mut sorted_entries: BTreeMap<u64, &str> = BTreeMap::new();
+
+    for (key, value) in table_map {
+        if let Some(value) = value.as_integer() {
+            if !(0..=0x7FF).contains(&value) {
+                panic!("Invalid APID value: {}", value);
+            }
+            sorted_entries.insert(value as u64, key);
+        }
+    }
+    sorted_entries
+}
+
+fn generate_rust_code(config: &Value, writer: &mut impl Write) {
+    writeln!(
+        writer,
+        "//! This is an auto-generated configuration module."
+    )
+    .unwrap();
+    writeln!(writer, "use satrs::request::UniqueApidTargetId;").unwrap();
+    writeln!(writer).unwrap();
+
+    // Generate the main module
+    writeln!(
+        writer,
+        "#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]"
+    )
+    .unwrap();
+    writeln!(writer, "pub enum Apid {{").unwrap();
+
+    // Generate constants for the main module
+    if let Some(apid_table) = config.get("apid").and_then(Value::as_table) {
+        let sorted_entries = sort_enum_table(apid_table);
+        // Write the sorted entries to the writer
+        for (value, key) in sorted_entries {
+            writeln!(writer, "    {} = {},", key, value).unwrap();
+        }
+    }
+    writeln!(writer, "}}").unwrap();
+
+    // Generate ID tables.
+    if let Some(id_tables) = config.get("ids").and_then(Value::as_table) {
+        for (mod_name, table) in id_tables {
+            let mod_name_as_snake = mod_name.to_snake_case();
+            writeln!(writer).unwrap();
+            writeln!(writer, "pub mod {} {{", mod_name_as_snake).unwrap();
+            let sorted_entries = sort_enum_table(table.as_table().unwrap());
+            writeln!(writer, "    #[derive(Debug, Copy, Clone, PartialEq, Eq)]").unwrap();
+            writeln!(writer, "    pub enum Id {{").unwrap();
+            // Write the sorted entries to the writer
+            for (value, key) in &sorted_entries {
+                writeln!(writer, "        {} = {},", key, value).unwrap();
+            }
+            writeln!(writer, "    }}").unwrap();
+            writeln!(writer).unwrap();
+
+            for (_value, key) in sorted_entries {
+                let key_shouting = key.to_shouty_snake_case();
+                writeln!(
+                    writer,
+                    "    pub const {}: super::UniqueApidTargetId = super::UniqueApidTargetId::new(super::Apid::{} as u16, Id::{} as u32);",
+                key_shouting, mod_name, key
+                ).unwrap();
+            }
+
+            writeln!(writer, "}}").unwrap();
+        }
+    }
+}
--- a/satrs-book/src/constrained-systems.md
+++ b/satrs-book/src/constrained-systems.md
@@ -3,20 +3,20 @@
 Software for space systems oftentimes has different requirements than the software for host
 systems or servers. Currently, most space systems are considered embedded systems.

-For these systems, the computation power and the available heap are the most important resources
-which are constrained. This might make completeley heap based memory management schemes which
+For these systems, the computation power and the available heap are important resources
+which are also constrained. This might make completeley heap based memory management schemes which
 are oftentimes used on host and server based systems unfeasable. Still, completely forbidding
 heap allocations might make software development unnecessarilly difficult, especially in a
 time where the OBSW might be running on Linux based systems with hundreds of MBs of RAM.

-A useful pattern used commonly in space systems is to limit heap allocations to program
+A useful pattern commonly used in space systems is to limit heap allocations to program
 initialization time and avoid frequent run-time allocations. This prevents issues like
 running out of memory (something even Rust can not protect from) or heap fragmentation on systems
 without a MMU.

 # Using pre-allocated pool structures

-A huge candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
+A candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
 candidates where the data size might vary greatly. The regular solution for host systems
 might be to send around this data as a `Vec<u8>` until it is dropped. `sat-rs` provides
 another solution to avoid run-time allocations by offering pre-allocated static
--- a/satrs-example/Cargo.toml
+++ b/satrs-example/Cargo.toml
@@ -18,7 +18,7 @@ csv = "1"
 num_enum = "0.7"
 thiserror = "2"
 lazy_static = "1"
-strum = { version = "0.26", features = ["derive"] }
+strum = { version = "0.27", features = ["derive"] }
 derive-new = "0.7"
 cfg-if = "1"
 serde = { version = "1", features = ["derive"] }
--- a/satrs-example/src/acs/mgm.rs
+++ b/satrs-example/src/acs/mgm.rs
@@ -2,7 +2,7 @@ use derive_new::new;
 use satrs::hk::{HkRequest, HkRequestVariant};
 use satrs::mode_tree::{ModeChild, ModeNode};
 use satrs::power::{PowerSwitchInfo, PowerSwitcherCommandSender};
-use satrs_example::config::pus::PUS_MODE_SERVICE;
+use satrs_example::ids::generic_pus::PUS_MODE;
 use satrs_example::{DeviceMode, TimestampHelper};
 use satrs_minisim::acs::lis3mdl::{
    MgmLis3MdlReply, MgmLis3RawValues, FIELD_LSB_PER_GAUSS_4_SENS, GAUSS_TO_MICROTESLA_FACTOR,
@@ -83,7 +83,7 @@ impl SpiInterface for SpiSimInterface {
            .sim_request_tx
            .send(SimRequest::new_with_epoch_time(mgm_sensor_request))
        {
-            log::error!("failed to send MGM LIS3 request: {}", e);
+            log::error!("failed to send MGM LIS3 request: {e}");
        }
        match self.sim_reply_rx.recv_timeout(Duration::from_millis(50)) {
            Ok(sim_reply) => {
@@ -97,7 +97,7 @@ impl SpiInterface for SpiSimInterface {
                    .copy_from_slice(&sim_reply_lis3.raw.z.to_le_bytes());
            }
            Err(e) => {
-                log::warn!("MGM LIS3 SIM reply timeout: {}", e);
+                log::warn!("MGM LIS3 SIM reply timeout: {e}");
            }
        }
        Ok(())
@@ -417,7 +417,7 @@ impl<
            if requestor.sender_id() == NO_SENDER {
                return Ok(());
            }
-            if requestor.sender_id() != PUS_MODE_SERVICE.id() {
+            if requestor.sender_id() != PUS_MODE.id() {
                log::warn!(
                    "can not send back mode reply to sender {:x}",
                    requestor.sender_id()
@@ -434,7 +434,7 @@ impl<
        requestor: MessageMetadata,
        reply: ModeReply,
    ) -> Result<(), Self::Error> {
-        if requestor.sender_id() != PUS_MODE_SERVICE.id() {
+        if requestor.sender_id() != PUS_MODE.id() {
            log::warn!(
                "can not send back mode reply to sender {}",
                requestor.sender_id()
@@ -492,7 +492,7 @@ mod tests {
        tmtc::PacketAsVec,
        ComponentId,
    };
-    use satrs_example::config::{acs::MGM_ASSEMBLY, components::Apid};
+    use satrs_example::ids::{acs::ASSEMBLY, Apid};
    use satrs_minisim::acs::lis3mdl::MgmLis3RawValues;

    use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest};
@@ -538,7 +538,7 @@ mod tests {

    impl ModeNode for MgmAssemblyMock {
        fn id(&self) -> satrs::ComponentId {
-            PUS_MODE_SERVICE.into()
+            PUS_MODE.into()
        }
    }

@@ -557,7 +557,7 @@ mod tests {

    impl ModeNode for PusMock {
        fn id(&self) -> satrs::ComponentId {
-            PUS_MODE_SERVICE.into()
+            PUS_MODE.into()
        }
    }

@@ -592,8 +592,8 @@ mod tests {
                TestSpiInterface::default(),
                shared_mgm_set,
            );
-            handler.add_mode_parent(PUS_MODE_SERVICE.into(), reply_tx_to_pus);
-            handler.add_mode_parent(MGM_ASSEMBLY.into(), reply_tx_to_parent);
+            handler.add_mode_parent(PUS_MODE.into(), reply_tx_to_pus);
+            handler.add_mode_parent(ASSEMBLY.into(), reply_tx_to_parent);
            Self {
                mode_request_tx: request_tx,
                mode_reply_rx_to_pus: reply_rx_to_pus,
@@ -631,7 +631,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                MessageMetadata::new(0, PUS_MODE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -692,7 +692,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                MessageMetadata::new(0, PUS_MODE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
--- a/satrs-example/src/bin/simpleclient.rs
+++ b/satrs-example/src/bin/simpleclient.rs
@@ -1,10 +1,7 @@
 use satrs::pus::verification::RequestId;
 use satrs::spacepackets::ecss::tc::PusTcCreator;
 use satrs::spacepackets::ecss::tm::PusTmReader;
-use satrs::{
-    spacepackets::ecss::{PusPacket, WritablePusPacket},
-    spacepackets::SpHeader,
-};
+use satrs::{spacepackets::ecss::PusPacket, spacepackets::SpHeader};
 use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
 use std::net::{IpAddr, SocketAddr, UdpSocket};
 use std::time::Duration;
@@ -29,7 +26,7 @@ fn main() {
        let res = client.recv(&mut buf);
        match res {
            Ok(_len) => {
-                let (pus_tm, size) = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
+                let pus_tm = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
                if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
                    println!("Received PUS Ping Reply TM[17,2]")
                } else if pus_tm.service() == 1 {
--- a/satrs-example/src/config.rs
+++ b/satrs-example/src/config.rs
@@ -43,14 +43,14 @@ pub const TEST_EVENT: EventU32TypedSev<SeverityInfo> = EventU32TypedSev::<Severi
 lazy_static! {
    pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
        let mut set = HashSet::new();
-        for id in components::Apid::iter() {
+        for id in crate::ids::Apid::iter() {
            set.insert(PacketId::new(PacketType::Tc, true, id as u16));
        }
        set
    };
    pub static ref APID_VALIDATOR: HashSet<u16> = {
        let mut set = HashSet::new();
-        for id in components::Apid::iter() {
+        for id in crate::ids::Apid::iter() {
            set.insert(id as u16);
        }
        set
@@ -122,92 +122,11 @@ pub mod mode_err {
 }

 pub mod components {
-    use satrs::{request::UniqueApidTargetId, ComponentId};
-    use strum::EnumIter;
+    use satrs::ComponentId;

-    #[derive(Copy, Clone, PartialEq, Eq, EnumIter)]
-    pub enum Apid {
-        Sched = 1,
-        GenericPus = 2,
-        Acs = 3,
-        Cfdp = 4,
-        Tmtc = 5,
-        Eps = 6,
-    }
-
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum EpsId {
-        Pcdu = 0,
-        Subsystem = 1,
-    }
-
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum TmtcId {
-        UdpServer = 0,
-        TcpServer = 1,
-    }
-
-    pub const EPS_SUBSYSTEM: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Subsystem as u32);
-    pub const PCDU_HANDLER: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Pcdu 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 const NO_SENDER: ComponentId = ComponentId::MAX;
 }

-pub mod pus {
-    use super::components::Apid;
-    use satrs::request::UniqueApidTargetId;
-
-    // Component IDs for components with the PUS APID.
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum PusId {
-        PusEventManagement = 0,
-        PusRouting = 1,
-        PusTest = 2,
-        PusAction = 3,
-        PusMode = 4,
-        PusHk = 5,
-    }
-    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 mod acs {
-    use super::components::Apid;
-    use satrs::request::UniqueApidTargetId;
-
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum AcsId {
-        Subsystem = 1,
-        Assembly = 2,
-        Mgm0 = 3,
-        Mgm1 = 4,
-    }
-
-    pub const MGM_ASSEMBLY: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Assembly as u32);
-    pub const MGM_HANDLER_0: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
-    pub const MGM_HANDLER_1: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
-}
-
 pub mod pool {
    use super::*;
    pub fn create_static_pools() -> (StaticMemoryPool, StaticMemoryPool) {
--- a/satrs-example/src/eps/pcdu.rs
+++ b/satrs-example/src/eps/pcdu.rs
@@ -20,10 +20,8 @@ use satrs::{
    spacepackets::ByteConversionError,
 };
 use satrs_example::{
-    config::{
-        components::{NO_SENDER, PCDU_HANDLER},
-        pus::PUS_MODE_SERVICE,
-    },
+    config::components::NO_SENDER,
+    ids::{eps::PCDU, generic_pus::PUS_MODE},
    DeviceMode, TimestampHelper,
 };
 use satrs_minisim::{
@@ -403,7 +401,7 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
                }
            }
        }) {
-            log::warn!("receiving PCDU replies failed: {:?}", e);
+            log::warn!("receiving PCDU replies failed: {e:?}");
        }
    }
 }
@@ -452,7 +450,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf
            if requestor.sender_id() == NO_SENDER {
                return Ok(());
            }
-            if requestor.sender_id() != PUS_MODE_SERVICE.id() {
+            if requestor.sender_id() != PUS_MODE.id() {
                log::warn!(
                    "can not send back mode reply to sender {}",
                    requestor.sender_id()
@@ -469,7 +467,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf
        requestor: MessageMetadata,
        reply: ModeReply,
    ) -> Result<(), Self::Error> {
-        if requestor.sender_id() != PUS_MODE_SERVICE.id() {
+        if requestor.sender_id() != PUS_MODE.id() {
            log::warn!(
                "can not send back mode reply to sender {}",
                requestor.sender_id()
@@ -492,7 +490,7 @@ impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterf

 impl<ComInterface: SerialInterface> ModeNode for PcduHandler<ComInterface> {
    fn id(&self) -> satrs::ComponentId {
-        PCDU_HANDLER.into()
+        PCDU.into()
    }
 }

@@ -511,10 +509,7 @@ mod tests {
    use satrs::{
        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
    };
-    use satrs_example::config::{
-        acs::MGM_HANDLER_0,
-        components::{Apid, EPS_SUBSYSTEM, PCDU_HANDLER},
-    };
+    use satrs_example::ids::{self, Apid};
    use satrs_minisim::eps::SwitchMapBinary;

    use super::*;
@@ -570,8 +565,7 @@ mod tests {
            let (mode_request_tx, mode_request_rx) = mpsc::sync_channel(5);
            let (mode_reply_tx_to_pus, mode_reply_rx_to_pus) = mpsc::sync_channel(5);
            let (mode_reply_tx_to_parent, mode_reply_rx_to_parent) = mpsc::sync_channel(5);
-            let mode_node =
-                ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), mode_request_rx);
+            let mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), mode_request_rx);
            let (composite_request_tx, composite_request_rx) = mpsc::channel();
            let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
            let (tm_tx, tm_rx) = mpsc::sync_channel::<PacketAsVec>(5);
@@ -588,8 +582,8 @@ mod tests {
                SerialInterfaceTest::default(),
                shared_switch_map,
            );
-            handler.add_mode_parent(EPS_SUBSYSTEM.into(), mode_reply_tx_to_parent);
-            handler.add_mode_parent(PUS_MODE_SERVICE.into(), mode_reply_tx_to_pus);
+            handler.add_mode_parent(ids::eps::SUBSYSTEM.into(), mode_reply_tx_to_parent);
+            handler.add_mode_parent(PUS_MODE.into(), mode_reply_tx_to_pus);
            Self {
                mode_request_tx,
                mode_reply_rx_to_pus,
@@ -684,7 +678,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                MessageMetadata::new(0, PUS_MODE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -719,7 +713,7 @@ mod tests {
        testbench
            .mode_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                MessageMetadata::new(0, PUS_MODE.id()),
                ModeRequest::SetMode {
                    mode_and_submode: ModeAndSubmode::new(DeviceMode::Normal as u32, 0),
                    forced: false,
@@ -729,7 +723,7 @@ mod tests {
        testbench
            .switch_request_tx
            .send(GenericMessage::new(
-                MessageMetadata::new(0, MGM_HANDLER_0.id()),
+                MessageMetadata::new(0, ids::acs::MGM0.id()),
                SwitchRequest::new(0, SwitchStateBinary::On),
            ))
            .expect("failed to send switch request");
--- a/satrs-example/src/events.rs
+++ b/satrs-example/src/events.rs
@@ -2,7 +2,7 @@ use std::sync::mpsc::{self};

 use crate::pus::create_verification_reporter;
 use satrs::event_man::{EventMessageU32, EventRoutingError};
-use satrs::pus::event::EventTmHookProvider;
+use satrs::pus::event::EventTmHook;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::EcssTmSender;
 use satrs::request::UniqueApidTargetId;
@@ -16,7 +16,7 @@ use satrs::{
    },
    spacepackets::time::cds::CdsTime,
 };
-use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;
+use satrs_example::ids::generic_pus::PUS_EVENT_MANAGEMENT;

 use crate::update_time;

@@ -26,7 +26,7 @@ pub struct EventApidSetter {
    pub next_apid: u16,
 }

-impl EventTmHookProvider for EventApidSetter {
+impl EventTmHook for EventApidSetter {
    fn modify_tm(&self, tm: &mut satrs::spacepackets::ecss::tm::PusTmCreator) {
        tm.set_apid(self.next_apid);
    }
@@ -219,7 +219,7 @@ impl<TmSender: EcssTmSender> EventHandler<TmSender> {
 mod tests {
    use satrs::{
        events::EventU32,
-        pus::verification::VerificationReporterCfg,
+        pus::verification::VerificationReporterConfig,
        spacepackets::{
            ecss::{tm::PusTmReader, PusPacket},
            CcsdsPacket,
@@ -244,7 +244,7 @@ mod tests {
            let (event_tx, event_rx) = mpsc::sync_channel(10);
            let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10);
            let (tm_sender, tm_receiver) = mpsc::channel();
-            let verif_reporter_cfg = VerificationReporterCfg::new(0x05, 2, 2, 128).unwrap();
+            let verif_reporter_cfg = VerificationReporterConfig::new(0x05, 2, 2, 128).unwrap();
            let verif_reporter =
                VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg);
            let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);
@@ -281,9 +281,7 @@ mod tests {
            .try_recv()
            .expect("failed to receive TM packet");
        assert_eq!(tm_packet.sender_id, PUS_EVENT_MANAGEMENT.id());
-        let tm_reader = PusTmReader::new(&tm_packet.packet, 7)
-            .expect("failed to create TM reader")
-            .0;
+        let tm_reader = PusTmReader::new(&tm_packet.packet, 7).expect("failed to create TM reader");
        assert_eq!(tm_reader.apid(), TEST_CREATOR_ID.apid);
        assert_eq!(tm_reader.user_data().len(), 4);
        let event_read_back = EventU32::from_be_bytes(tm_reader.user_data().try_into().unwrap());
--- a/satrs-example/src/ids.rs
+++ b/satrs-example/src/ids.rs
@@ -0,0 +1,94 @@
+//! This is an auto-generated configuration module.
+use satrs::request::UniqueApidTargetId;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)]
+pub enum Apid {
+    Sched = 1,
+    GenericPus = 2,
+    Acs = 3,
+    Cfdp = 4,
+    Tmtc = 5,
+    Eps = 6,
+}
+
+pub mod acs {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        Subsystem = 1,
+        Assembly = 2,
+        Mgm0 = 3,
+        Mgm1 = 4,
+    }
+
+    pub const SUBSYSTEM: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32);
+    pub const ASSEMBLY: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Assembly as u32);
+    pub const MGM0: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32);
+    pub const MGM1: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm1 as u32);
+}
+
+pub mod eps {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        Pcdu = 0,
+        Subsystem = 1,
+    }
+
+    pub const PCDU: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Pcdu as u32);
+    pub const SUBSYSTEM: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Subsystem as u32);
+}
+
+pub mod generic_pus {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        PusEventManagement = 0,
+        PusRouting = 1,
+        PusTest = 2,
+        PusAction = 3,
+        PusMode = 4,
+        PusHk = 5,
+    }
+
+    pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
+        super::Apid::GenericPus as u16,
+        Id::PusEventManagement as u32,
+    );
+    pub const PUS_ROUTING: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusRouting as u32);
+    pub const PUS_TEST: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusTest as u32);
+    pub const PUS_ACTION: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusAction as u32);
+    pub const PUS_MODE: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusMode as u32);
+    pub const PUS_HK: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusHk as u32);
+}
+
+pub mod sched {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        PusSched = 0,
+    }
+
+    pub const PUS_SCHED: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Sched as u16, Id::PusSched as u32);
+}
+
+pub mod tmtc {
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Id {
+        UdpServer = 0,
+        TcpServer = 1,
+    }
+
+    pub const UDP_SERVER: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::UdpServer as u32);
+    pub const TCP_SERVER: super::UniqueApidTargetId =
+        super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::TcpServer as u32);
+}
--- a/satrs-example/src/interface/sim_client_udp.rs
+++ b/satrs-example/src/interface/sim_client_udp.rs
@@ -24,7 +24,7 @@ pub fn create_sim_client(sim_request_rx: mpsc::Receiver<SimRequest>) -> Option<S
            return Some(sim_client);
        }
        Err(e) => {
-            log::warn!("sim client creation error: {}", e);
+            log::warn!("sim client creation error: {e}");
        }
    }
    None
@@ -116,7 +116,7 @@ impl SimClientUdp {
                        .udp_client
                        .send_to(request_json.as_bytes(), self.simulator_addr)
                    {
-                        log::error!("error sending data to UDP SIM server: {}", e);
+                        log::error!("error sending data to UDP SIM server: {e}");
                        break;
                    } else {
                        no_sim_requests_handled = false;
@@ -151,7 +151,7 @@ impl SimClientUdp {
                            }
                        }
                        Err(e) => {
-                            log::warn!("failed to deserialize SIM reply: {}", e);
+                            log::warn!("failed to deserialize SIM reply: {e}");
                        }
                    }
                }
@@ -161,7 +161,7 @@ impl SimClientUdp {
                    {
                        break;
                    }
-                    log::error!("error receiving data from UDP SIM server: {}", e);
+                    log::error!("error receiving data from UDP SIM server: {e}");
                    break;
                }
            }
--- a/satrs-example/src/interface/tcp.rs
+++ b/satrs-example/src/interface/tcp.rs
@@ -31,7 +31,7 @@ impl SpacePacketValidator for SimplePacketValidator {
        if self.valid_ids.contains(&sp_header.packet_id()) {
            return SpValidity::Valid;
        }
-        log::warn!("ignoring space packet with header {:?}", sp_header);
+        log::warn!("ignoring space packet with header {sp_header:?}");
        // We could perform a CRC check.. but lets keep this simple and assume that TCP ensures
        // data integrity.
        SpValidity::Skip
--- a/satrs-example/src/interface/udp.rs
+++ b/satrs-example/src/interface/udp.rs
@@ -15,6 +15,7 @@ pub trait UdpTmHandler {
    fn send_tm_to_udp_client(&mut self, socket: &UdpSocket, recv_addr: &SocketAddr);
 }

+#[allow(dead_code)]
 pub struct StaticUdpTmHandler {
    pub tm_rx: mpsc::Receiver<PacketInPool>,
    pub tm_store: SharedStaticMemoryPool,
@@ -119,7 +120,8 @@ mod tests {
        },
        ComponentId,
    };
-    use satrs_example::config::{components, OBSW_SERVER_ADDR};
+    use satrs_example::config::OBSW_SERVER_ADDR;
+    use satrs_example::ids;

    use crate::tmtc::sender::{MockSender, TmTcSender};

@@ -175,7 +177,7 @@ mod tests {
            udp_tc_server,
            tm_handler,
        };
-        let sph = SpHeader::new_for_unseg_tc(components::Apid::GenericPus as u16, 0, 0);
+        let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus as u16, 0, 0);
        let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true)
            .to_vec()
            .unwrap();
--- a/satrs-example/src/lib.rs
+++ b/satrs-example/src/lib.rs
@@ -1,6 +1,7 @@
 use satrs::spacepackets::time::{cds::CdsTime, TimeWriter};

 pub mod config;
+pub mod ids;

 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum DeviceMode {
--- a/satrs-example/src/main.rs
+++ b/satrs-example/src/main.rs
@@ -33,18 +33,22 @@ use satrs::{
    hal::std::{tcp_server::ServerConfig, udp_server::UdpTcServer},
    mode::{Mode, ModeAndSubmode, ModeRequest, ModeRequestHandlerMpscBounded},
    mode_tree::connect_mode_nodes,
-    pus::{event_man::EventRequestWithToken, EcssTcInMemConverter, HandlingStatus},
+    pus::{event_man::EventRequestWithToken, EcssTcCacher, HandlingStatus},
    request::{GenericMessage, MessageMetadata},
    spacepackets::time::{cds::CdsTime, TimeWriter},
 };
 use satrs_example::{
    config::{
-        acs::{MGM_HANDLER_0, MGM_HANDLER_1},
-        components::{NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER},
+        components::NO_SENDER,
        pool::create_sched_tc_pool,
        tasks::{FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
        OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
    },
+    ids::{
+        acs::*,
+        eps::*,
+        tmtc::{TCP_SERVER, UDP_SERVER},
+    },
    DeviceMode,
 };
 use tmtc::sender::TmTcSender;
@@ -53,12 +57,12 @@ use tmtc::{tc_source::TcSourceTask, tm_sink::TmSink};
 cfg_if::cfg_if! {
    if #[cfg(feature = "heap_tmtc")] {
        use interface::udp::DynamicUdpTmHandler;
-        use satrs::pus::EcssTcInVecConverter;
+        use satrs::pus::EcssTcVecCacher;
        use tmtc::{tc_source::TcSourceTaskDynamic, tm_sink::TmSinkDynamic};
    } else {
        use std::sync::RwLock;
        use interface::udp::StaticUdpTmHandler;
-        use satrs::pus::EcssTcInSharedPoolConverter;
+        use satrs::pus::EcssTcInSharedPoolCacher;
        use satrs::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
        use satrs_example::config::pool::create_static_pools;
        use tmtc::{
@@ -124,13 +128,13 @@ fn main() {
    let mut request_map = GenericRequestRouter::default();
    request_map
        .composite_router_map
-        .insert(MGM_HANDLER_0.id(), mgm_0_handler_composite_tx);
+        .insert(MGM0.id(), mgm_0_handler_composite_tx);
    request_map
        .composite_router_map
-        .insert(MGM_HANDLER_0.id(), mgm_1_handler_composite_tx);
+        .insert(MGM1.id(), mgm_1_handler_composite_tx);
    request_map
        .composite_router_map
-        .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
+        .insert(PCDU.id(), pcdu_handler_composite_tx);

    // This helper structure is used by all telecommand providers which need to send telecommands
    // to the TC source.
@@ -139,9 +143,9 @@ fn main() {
            let tc_sender_with_shared_pool =
                PacketSenderWithSharedPool::new(tc_source_tx, shared_tc_pool_wrapper.clone());
            let tc_in_mem_converter =
-                EcssTcInMemConverter::Static(EcssTcInSharedPoolConverter::new(shared_tc_pool, 4096));
+                EcssTcCacher::Static(EcssTcInSharedPoolCacher::new(shared_tc_pool, 4096));
        } else if #[cfg(feature = "heap_tmtc")] {
-            let tc_in_mem_converter = EcssTcInMemConverter::Heap(EcssTcInVecConverter::default());
+            let tc_in_mem_converter = EcssTcCacher::Heap(EcssTcVecCacher::default());
        }
    }

@@ -301,10 +305,8 @@ fn main() {

    let shared_mgm_0_set = Arc::default();
    let shared_mgm_1_set = Arc::default();
-    let mgm_0_mode_node =
-        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_0_handler_mode_rx);
-    let mgm_1_mode_node =
-        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_1.into(), mgm_1_handler_mode_rx);
+    let mgm_0_mode_node = ModeRequestHandlerMpscBounded::new(MGM0.into(), mgm_0_handler_mode_rx);
+    let mgm_1_mode_node = ModeRequestHandlerMpscBounded::new(MGM1.into(), mgm_1_handler_mode_rx);
    let (mgm_0_spi_interface, mgm_1_spi_interface) =
        if let Some(sim_client) = opt_sim_client.as_mut() {
            sim_client
@@ -328,7 +330,7 @@ fn main() {
            )
        };
    let mut mgm_0_handler = MgmHandlerLis3Mdl::new(
-        MGM_HANDLER_0,
+        MGM0,
        "MGM_0",
        mgm_0_mode_node,
        mgm_0_handler_composite_rx,
@@ -339,7 +341,7 @@ fn main() {
        shared_mgm_0_set,
    );
    let mut mgm_1_handler = MgmHandlerLis3Mdl::new(
-        MGM_HANDLER_1,
+        MGM1,
        "MGM_1",
        mgm_1_mode_node,
        mgm_1_handler_composite_rx,
@@ -372,10 +374,9 @@ fn main() {
    } else {
        SerialSimInterfaceWrapper::Dummy(SerialInterfaceDummy::default())
    };
-    let pcdu_mode_node =
-        ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), pcdu_handler_mode_rx);
+    let pcdu_mode_node = ModeRequestHandlerMpscBounded::new(PCDU.into(), pcdu_handler_mode_rx);
    let mut pcdu_handler = PcduHandler::new(
-        PCDU_HANDLER,
+        PCDU,
        "PCDU",
        pcdu_mode_node,
        pcdu_handler_composite_rx,
--- a/satrs-example/src/pus/action.rs
+++ b/satrs-example/src/pus/action.rs
@@ -9,15 +9,16 @@ use satrs::pus::verification::{
    VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConverter, EcssTmSender, EcssTmtcError,
+    ActiveRequest, EcssTcAndToken, EcssTcCacher, EcssTmSender, EcssTmtcError,
    GenericConversionError, MpscTcReceiver, PusPacketHandlingError, PusReplyHandler,
    PusServiceHelper, PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket, PusServiceId};
-use satrs_example::config::pus::PUS_ACTION_SERVICE;
 use satrs_example::config::tmtc_err;
+use satrs_example::ids;
+use satrs_example::ids::generic_pus::PUS_ACTION;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -207,17 +208,17 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio

 pub fn create_action_service(
    tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
    pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
    action_router: GenericRequestRouter,
    reply_receiver: mpsc::Receiver<GenericMessage<ActionReplyPus>>,
 ) -> ActionServiceWrapper {
    let action_request_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            PUS_ACTION_SERVICE.id(),
+            ids::generic_pus::PUS_ACTION.id(),
            pus_action_rx,
            tm_sender,
-            create_verification_reporter(PUS_ACTION_SERVICE.id(), PUS_ACTION_SERVICE.apid),
+            create_verification_reporter(PUS_ACTION.id(), PUS_ACTION.apid),
            tc_in_mem_converter,
        ),
        ActionRequestConverter::default(),
@@ -273,7 +274,7 @@ mod tests {
        TEST_APID, TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
    };
    use satrs::pus::verification::test_util::TestVerificationReporter;
-    use satrs::pus::{verification, EcssTcInVecConverter};
+    use satrs::pus::{verification, EcssTcVecCacher};
    use satrs::request::MessageMetadata;
    use satrs::tmtc::PacketAsVec;
    use satrs::ComponentId;
@@ -324,7 +325,7 @@ mod tests {
                        pus_action_rx,
                        TmTcSender::Heap(tm_funnel_tx.clone()),
                        verif_reporter,
-                        EcssTcInMemConverter::Heap(EcssTcInVecConverter::default()),
+                        EcssTcCacher::Heap(EcssTcVecCacher::default()),
                    ),
                    ActionRequestConverter::default(),
                    DefaultActiveActionRequestMap::default(),
@@ -367,7 +368,7 @@ mod tests {
            if let Err(mpsc::TryRecvError::Empty) = packet {
            } else {
                let tm = packet.unwrap();
-                let unexpected_tm = PusTmReader::new(&tm.packet, 7).unwrap().0;
+                let unexpected_tm = PusTmReader::new(&tm.packet, 7).unwrap();
                panic!("unexpected TM packet {unexpected_tm:?}");
            }
        }
@@ -410,7 +411,11 @@ mod tests {

        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 token = self
+                .service
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
            let accepted_token = self
                .service
                .service_helper
--- a/satrs-example/src/pus/event.rs
+++ b/satrs-example/src/pus/event.rs
@@ -6,17 +6,17 @@ use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusEventServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
+    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher, MpscTcReceiver,
    PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
-use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;
+use satrs_example::ids::generic_pus::PUS_EVENT_MANAGEMENT;

 use super::{DirectPusService, HandlingStatus};

 pub fn create_event_service(
    tm_sender: TmTcSender,
-    tm_in_pool_converter: EcssTcInMemConverter,
+    tm_in_pool_converter: EcssTcCacher,
    pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
    event_request_tx: mpsc::Sender<EventRequestWithToken>,
 ) -> EventServiceWrapper {
@@ -36,12 +36,8 @@ pub fn create_event_service(
 }

 pub struct EventServiceWrapper {
-    pub handler: PusEventServiceHandler<
-        MpscTcReceiver,
-        TmTcSender,
-        EcssTcInMemConverter,
-        VerificationReporter,
-    >,
+    pub handler:
+        PusEventServiceHandler<MpscTcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
 }

 impl DirectPusService for EventServiceWrapper {
--- a/satrs-example/src/pus/hk.rs
+++ b/satrs-example/src/pus/hk.rs
@@ -5,16 +5,16 @@ use satrs::pus::verification::{
    VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap, EcssTcAndToken,
-    EcssTcInMemConverter, EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver,
-    PusPacketHandlingError, PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
+    ActivePusRequestStd, ActiveRequest, DefaultActiveRequestMap, EcssTcAndToken, EcssTcCacher,
+    EcssTmSender, EcssTmtcError, GenericConversionError, MpscTcReceiver, PusPacketHandlingError,
+    PusReplyHandler, PusServiceHelper, PusTcToRequestConverter,
 };
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::res_code::ResultU16;
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket, PusServiceId};
-use satrs_example::config::pus::PUS_HK_SERVICE;
 use satrs_example::config::{hk_err, tmtc_err};
+use satrs_example::ids::generic_pus::PUS_HK;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -242,17 +242,17 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver

 pub fn create_hk_service(
    tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
    pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
    request_router: GenericRequestRouter,
    reply_receiver: mpsc::Receiver<GenericMessage<HkReply>>,
 ) -> HkServiceWrapper {
    let pus_3_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            PUS_HK_SERVICE.id(),
+            PUS_HK.id(),
            pus_hk_rx,
            tm_sender,
-            create_verification_reporter(PUS_HK_SERVICE.id(), PUS_HK_SERVICE.apid),
+            create_verification_reporter(PUS_HK.id(), PUS_HK.apid),
            tc_in_mem_converter,
        ),
        HkRequestConverter::default(),
--- a/satrs-example/src/pus/mod.rs
+++ b/satrs-example/src/pus/mod.rs
@@ -4,13 +4,13 @@ use log::warn;
 use satrs::pool::PoolAddr;
 use satrs::pus::verification::{
    self, FailParams, TcStateAccepted, TcStateStarted, VerificationReporter,
-    VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
+    VerificationReporterConfig, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
-    ActiveRequestMapProvider, ActiveRequestProvider, EcssTcAndToken, EcssTcInMemConversionProvider,
-    EcssTcInMemConverter, EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError,
-    GenericRoutingError, HandlingStatus, PusPacketHandlingError, PusReplyHandler, PusRequestRouter,
-    PusServiceHelper, PusTcToRequestConverter, TcInMemory,
+    ActiveRequest, ActiveRequestStore, CacheAndReadRawEcssTc, EcssTcAndToken, EcssTcCacher,
+    EcssTcReceiver, EcssTmSender, EcssTmtcError, GenericConversionError, GenericRoutingError,
+    HandlingStatus, PusPacketHandlingError, PusReplyHandler, PusRequestRouter, PusServiceHelper,
+    PusTcToRequestConverter, TcInMemory,
 };
 use satrs::queue::{GenericReceiveError, GenericSendError};
 use satrs::request::{Apid, GenericMessage, MessageMetadata};
@@ -18,8 +18,8 @@ use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
 use satrs::tmtc::{PacketAsVec, PacketInPool};
 use satrs::ComponentId;
-use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
+use satrs_example::ids::generic_pus::PUS_ROUTING;
 use satrs_example::TimestampHelper;
 use std::fmt::Debug;
 use std::sync::mpsc;
@@ -33,7 +33,7 @@ pub mod stack;
 pub mod test;

 pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> VerificationReporter {
-    let verif_cfg = VerificationReporterCfg::new(apid, 1, 2, 8).unwrap();
+    let verif_cfg = VerificationReporterConfig::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)
@@ -62,12 +62,9 @@ pub struct PusTcDistributor {
 impl PusTcDistributor {
    pub fn new(tm_sender: TmTcSender, pus_router: PusTcMpscRouter) -> Self {
        Self {
-            id: PUS_ROUTING_SERVICE.raw(),
+            id: PUS_ROUTING.raw(),
            tm_sender,
-            verif_reporter: create_verification_reporter(
-                PUS_ROUTING_SERVICE.id(),
-                PUS_ROUTING_SERVICE.apid,
-            ),
+            verif_reporter: create_verification_reporter(PUS_ROUTING.id(), PUS_ROUTING.apid),
            pus_router,
            stamp_helper: TimestampHelper::default(),
        }
@@ -105,12 +102,12 @@ impl PusTcDistributor {
                sender_id,
                pus_tc_result.unwrap_err()
            );
-            log::warn!("raw data: {:x?}", raw_tc);
+            log::warn!("raw data: {raw_tc:x?}");
            // TODO: Shouldn't this be an error?
            return Ok(HandlingStatus::HandledOne);
        }
-        let pus_tc = pus_tc_result.unwrap().0;
-        let init_token = self.verif_reporter.add_tc(&pus_tc);
+        let pus_tc = pus_tc_result.unwrap();
+        let init_token = self.verif_reporter.start_verification(&pus_tc);
        self.stamp_helper.update_from_now();
        let accepted_token = self
            .verif_reporter
@@ -272,16 +269,16 @@ pub struct PusTargetedRequestService<
    VerificationReporter: VerificationReportingProvider,
    RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
    ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-    ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
-    ActiveRequestInfo: ActiveRequestProvider,
+    ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
+    ActiveRequestInfo: ActiveRequest,
    RequestType,
    ReplyType,
 > {
    pub service_helper:
-        PusServiceHelper<TcReceiver, TmTcSender, EcssTcInMemConverter, VerificationReporter>,
+        PusServiceHelper<TcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
    pub request_router: GenericRequestRouter,
    pub request_converter: RequestConverter,
-    pub active_request_map: ActiveRequestMap,
+    pub active_request_map: ActiveRequestMapInstance,
    pub reply_handler: ReplyHandler,
    pub reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
    phantom: std::marker::PhantomData<(RequestType, ActiveRequestInfo, ReplyType)>,
@@ -292,8 +289,8 @@ impl<
        VerificationReporter: VerificationReportingProvider,
        RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
        ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
-        ActiveRequestInfo: ActiveRequestProvider,
+        ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequest,
        RequestType,
        ReplyType,
    >
@@ -302,7 +299,7 @@ impl<
        VerificationReporter,
        RequestConverter,
        ReplyHandler,
-        ActiveRequestMap,
+        ActiveRequestMapInstance,
        ActiveRequestInfo,
        RequestType,
        ReplyType,
@@ -314,11 +311,11 @@ where
        service_helper: PusServiceHelper<
            TcReceiver,
            TmTcSender,
-            EcssTcInMemConverter,
+            EcssTcCacher,
            VerificationReporter,
        >,
        request_converter: RequestConverter,
-        active_request_map: ActiveRequestMap,
+        active_request_map: ActiveRequestMapInstance,
        reply_hook: ReplyHandler,
        request_router: GenericRequestRouter,
        reply_receiver: mpsc::Receiver<GenericMessage<ReplyType>>,
@@ -512,7 +509,7 @@ where
 /// and also log the error.
 pub fn generic_pus_request_timeout_handler(
    sender: &(impl EcssTmSender + ?Sized),
-    active_request: &(impl ActiveRequestProvider + Debug),
+    active_request: &(impl ActiveRequest + Debug),
    verification_handler: &impl VerificationReportingProvider,
    time_stamp: &[u8],
    service_str: &'static str,
@@ -540,7 +537,7 @@ pub(crate) mod tests {
    use satrs::{
        pus::{
            verification::test_util::TestVerificationReporter, ActivePusRequestStd,
-            ActiveRequestMapProvider, MpscTcReceiver,
+            ActiveRequestStore, MpscTcReceiver,
        },
        request::UniqueApidTargetId,
        spacepackets::{
@@ -559,7 +556,7 @@ pub(crate) mod tests {
    // Testbench dedicated to the testing of [PusReplyHandler]s
    pub struct ReplyHandlerTestbench<
        ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
-        ActiveRequestInfo: ActiveRequestProvider,
+        ActiveRequestInfo: ActiveRequest,
        Reply,
    > {
        pub id: ComponentId,
@@ -573,7 +570,7 @@ pub(crate) mod tests {

    impl<
            ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
-            ActiveRequestInfo: ActiveRequestProvider,
+            ActiveRequestInfo: ActiveRequest,
            Reply,
        > ReplyHandlerTestbench<ReplyHandler, ActiveRequestInfo, Reply>
    {
@@ -599,7 +596,7 @@ pub(crate) mod tests {
        ) -> (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(
+            let init = self.verif_reporter.start_verification(&PusTcCreator::new(
                sp_header,
                sec_header_dummy,
                &[],
@@ -674,7 +671,7 @@ pub(crate) mod tests {
    // Testbench dedicated to the testing of [PusTcToRequestConverter]s
    pub struct PusConverterTestbench<
        Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
-        ActiveRequestInfo: ActiveRequestProvider,
+        ActiveRequestInfo: ActiveRequest,
        Request,
    > {
        pub id: ComponentId,
@@ -688,7 +685,7 @@ pub(crate) mod tests {

    impl<
            Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
-            ActiveRequestInfo: ActiveRequestProvider,
+            ActiveRequestInfo: ActiveRequest,
            Request,
        > PusConverterTestbench<Converter, ActiveRequestInfo, Request>
    {
@@ -706,7 +703,7 @@ pub(crate) mod tests {
        }

        pub fn add_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let token = self.verif_reporter.add_tc(tc);
+            let token = self.verif_reporter.start_verification(tc);
            self.current_request_id = Some(verification::RequestId::new(tc));
            self.current_packet = Some(tc.to_vec().unwrap());
            self.verif_reporter
@@ -734,7 +731,7 @@ pub(crate) mod tests {
            let tc_reader = PusTcReader::new(&current_packet).unwrap();
            let (active_info, request) = self.converter.convert(
                token,
-                &tc_reader.0,
+                &tc_reader,
                &self.dummy_sender,
                &self.verif_reporter,
                time_stamp,
@@ -754,8 +751,8 @@ pub(crate) mod tests {
    pub struct TargetedPusRequestTestbench<
        RequestConverter: PusTcToRequestConverter<ActiveRequestInfo, RequestType, Error = GenericConversionError>,
        ReplyHandler: PusReplyHandler<ActiveRequestInfo, ReplyType, Error = EcssTmtcError>,
-        ActiveRequestMap: ActiveRequestMapProvider<ActiveRequestInfo>,
-        ActiveRequestInfo: ActiveRequestProvider,
+        ActiveRequestMapInstance: ActiveRequestStore<ActiveRequestInfo>,
+        ActiveRequestInfo: ActiveRequest,
        RequestType,
        ReplyType,
    > {
@@ -764,7 +761,7 @@ pub(crate) mod tests {
            TestVerificationReporter,
            RequestConverter,
            ReplyHandler,
-            ActiveRequestMap,
+            ActiveRequestMapInstance,
            ActiveRequestInfo,
            RequestType,
            ReplyType,
--- a/satrs-example/src/pus/mode.rs
+++ b/satrs-example/src/pus/mode.rs
@@ -1,6 +1,6 @@
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
-use satrs_example::config::pus::PUS_MODE_SERVICE;
+use satrs_example::ids;
 use std::sync::mpsc;
 use std::time::Duration;

@@ -8,8 +8,8 @@ use crate::requests::GenericRequestRouter;
 use crate::tmtc::sender::TmTcSender;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DefaultActiveRequestMap, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
-    PusPacketHandlingError, PusServiceHelper,
+    DefaultActiveRequestMap, EcssTcAndToken, EcssTcCacher, MpscTcReceiver, PusPacketHandlingError,
+    PusServiceHelper,
 };
 use satrs::request::GenericMessage;
 use satrs::{
@@ -20,8 +20,8 @@ use satrs::{
            self, FailParams, TcStateAccepted, TcStateStarted, VerificationReportingProvider,
            VerificationToken,
        },
-        ActivePusRequestStd, ActiveRequestProvider, EcssTmSender, EcssTmtcError,
-        GenericConversionError, PusReplyHandler, PusTcToRequestConverter, PusTmVariant,
+        ActivePusRequestStd, ActiveRequest, EcssTmSender, EcssTmtcError, GenericConversionError,
+        PusReplyHandler, PusTcToRequestConverter, PusTmVariant,
    },
    request::UniqueApidTargetId,
    spacepackets::{
@@ -210,22 +210,25 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo

 pub fn create_mode_service(
    tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
    pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
    mode_router: GenericRequestRouter,
    reply_receiver: mpsc::Receiver<GenericMessage<ModeReply>>,
 ) -> ModeServiceWrapper {
    let mode_request_handler = PusTargetedRequestService::new(
        PusServiceHelper::new(
-            PUS_MODE_SERVICE.id(),
+            ids::generic_pus::PUS_MODE.id(),
            pus_action_rx,
            tm_sender,
-            create_verification_reporter(PUS_MODE_SERVICE.id(), PUS_MODE_SERVICE.apid),
+            create_verification_reporter(
+                ids::generic_pus::PUS_MODE.id(),
+                ids::generic_pus::PUS_MODE.apid,
+            ),
            tc_in_mem_converter,
        ),
        ModeRequestConverter::default(),
        DefaultActiveRequestMap::default(),
-        ModeReplyHandler::new(PUS_MODE_SERVICE.id()),
+        ModeReplyHandler::new(ids::generic_pus::PUS_MODE.id()),
        mode_router,
        reply_receiver,
    );
--- a/satrs-example/src/pus/scheduler.rs
+++ b/satrs-example/src/pus/scheduler.rs
@@ -9,13 +9,13 @@ use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusSchedServiceHandler;
 use satrs::pus::verification::VerificationReporter;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConverter, MpscTcReceiver,
+    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher, MpscTcReceiver,
    PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
 use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
 use satrs::ComponentId;
-use satrs_example::config::pus::PUS_SCHED_SERVICE;
+use satrs_example::ids::sched::PUS_SCHED;

 use super::{DirectPusService, HandlingStatus};

@@ -84,7 +84,7 @@ pub struct SchedulingServiceWrapper {
    pub pus_11_handler: PusSchedServiceHandler<
        MpscTcReceiver,
        TmTcSender,
-        EcssTcInMemConverter,
+        EcssTcCacher,
        VerificationReporter,
        PusScheduler,
    >,
@@ -174,7 +174,7 @@ impl SchedulingServiceWrapper {

 pub fn create_scheduler_service(
    tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
    tc_releaser: TcReleaser,
    pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
    sched_tc_pool: StaticMemoryPool,
@@ -183,10 +183,10 @@ pub fn create_scheduler_service(
        .expect("Creating PUS Scheduler failed");
    let pus_11_handler = PusSchedServiceHandler::new(
        PusServiceHelper::new(
-            PUS_SCHED_SERVICE.id(),
+            PUS_SCHED.id(),
            pus_sched_rx,
            tm_sender,
-            create_verification_reporter(PUS_SCHED_SERVICE.id(), PUS_SCHED_SERVICE.apid),
+            create_verification_reporter(PUS_SCHED.id(), PUS_SCHED.apid),
            tc_in_mem_converter,
        ),
        scheduler,
--- a/satrs-example/src/pus/test.rs
+++ b/satrs-example/src/pus/test.rs
@@ -6,28 +6,28 @@ use satrs::pus::test::PusService17TestHandler;
 use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
 use satrs::pus::PartialPusHandlingError;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConversionProvider,
-    EcssTcInMemConverter, MpscTcReceiver, PusServiceHelper,
+    CacheAndReadRawEcssTc, DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher,
+    MpscTcReceiver, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs_example::config::pus::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
+use satrs_example::ids::generic_pus::PUS_TEST;
 use std::sync::mpsc;

 use super::{DirectPusService, HandlingStatus};

 pub fn create_test_service(
    tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
    event_sender: mpsc::SyncSender<EventMessageU32>,
    pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper {
    let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
-        PUS_TEST_SERVICE.id(),
+        PUS_TEST.id(),
        pus_test_rx,
        tm_sender,
-        create_verification_reporter(PUS_TEST_SERVICE.id(), PUS_TEST_SERVICE.apid),
+        create_verification_reporter(PUS_TEST.id(), PUS_TEST.apid),
        tc_in_mem_converter,
    ));
    TestCustomServiceWrapper {
@@ -37,12 +37,8 @@ pub fn create_test_service(
 }

 pub struct TestCustomServiceWrapper {
-    pub handler: PusService17TestHandler<
-        MpscTcReceiver,
-        TmTcSender,
-        EcssTcInMemConverter,
-        VerificationReporter,
-    >,
+    pub handler:
+        PusService17TestHandler<MpscTcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
    pub event_tx: mpsc::SyncSender<EventMessageU32>,
 }

@@ -90,7 +86,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                );
            }
            DirectPusPacketHandlerResult::CustomSubservice(subservice, token) => {
-                let (tc, _) = PusTcReader::new(
+                let tc = PusTcReader::new(
                    self.handler
                        .service_helper
                        .tc_in_mem_converter
@@ -100,7 +96,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                if subservice == 128 {
                    info!("generating test event");
                    self.event_tx
-                        .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
+                        .send(EventMessage::new(PUS_TEST.id(), TEST_EVENT.into()))
                        .expect("Sending test event failed");
                    match self.handler.service_helper.verif_reporter().start_success(
                        self.handler.service_helper.tm_sender(),
--- a/satrs-example/src/requests.rs
+++ b/satrs-example/src/requests.rs
@@ -8,14 +8,14 @@ use satrs::mode::ModeRequest;
 use satrs::pus::verification::{
    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
-use satrs::pus::{ActiveRequestProvider, EcssTmSender, GenericRoutingError, PusRequestRouter};
+use satrs::pus::{ActiveRequest, EcssTmSender, GenericRoutingError, PusRequestRouter};
 use satrs::queue::GenericSendError;
 use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
-use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::tmtc_err;
+use satrs_example::ids;

 #[derive(Clone, Debug)]
 #[non_exhaustive]
@@ -37,7 +37,7 @@ pub struct GenericRequestRouter {
 impl Default for GenericRequestRouter {
    fn default() -> Self {
        Self {
-            id: PUS_ROUTING_SERVICE.raw(),
+            id: ids::generic_pus::PUS_ROUTING.raw(),
            composite_router_map: Default::default(),
            mode_router_map: Default::default(),
        }
@@ -46,7 +46,7 @@ impl Default for GenericRequestRouter {
 impl GenericRequestRouter {
    pub(crate) fn handle_error_generic(
        &self,
-        active_request: &impl ActiveRequestProvider,
+        active_request: &impl ActiveRequest,
        tc: &PusTcReader,
        error: GenericRoutingError,
        tm_sender: &(impl EcssTmSender + ?Sized),
--- a/satrs-example/src/tmtc/tc_source.rs
+++ b/satrs-example/src/tmtc/tc_source.rs
@@ -11,7 +11,9 @@ use crate::pus::PusTcDistributor;
 pub struct TcSourceTaskStatic {
    shared_tc_pool: SharedPacketPool,
    tc_receiver: mpsc::Receiver<PacketInPool>,
-    tc_buf: [u8; 4096],
+    /// We allocate this buffer from the heap to avoid a clippy warning on large enum variant
+    /// differences.
+    tc_buf: Box<[u8; 4096]>,
    pus_distributor: PusTcDistributor,
 }

@@ -25,7 +27,7 @@ impl TcSourceTaskStatic {
        Self {
            shared_tc_pool,
            tc_receiver,
-            tc_buf: [0; 4096],
+            tc_buf: Box::new([0; 4096]),
            pus_distributor: pus_receiver,
        }
    }
@@ -44,11 +46,11 @@ impl TcSourceTaskStatic {
                    .0
                    .read()
                    .expect("locking tc pool failed");
-                pool.read(&packet_in_pool.store_addr, &mut self.tc_buf)
+                pool.read(&packet_in_pool.store_addr, self.tc_buf.as_mut_slice())
                    .expect("reading pool failed");
                drop(pool);
                self.pus_distributor
-                    .handle_tc_packet_in_store(packet_in_pool, &self.tc_buf)
+                    .handle_tc_packet_in_store(packet_in_pool, self.tc_buf.as_slice())
                    .ok();
                HandlingStatus::HandledOne
            }
--- a/satrs-mib/CHANGELOG.md
+++ b/satrs-mib/CHANGELOG.md
@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

+# [v0.1.3] 2024-08-26
+
+Bump `satrs-shared`.
+
 # [v0.1.2] 2024-04-17

 Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
@@ -19,3 +23,6 @@ Allow `satrs-shared` from `v0.1.3` to `<v0.2`.
 # [v0.1.0] 2024-02-12

 Initial release containing the `resultcode` macro.
+
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-mib-v0.1.3...HEAD
+[v0.1.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-mib-v0.1.2...satrs-mib-v0.1.3
--- a/satrs-mib/Cargo.toml
+++ b/satrs-mib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
@@ -23,7 +23,8 @@ version = "1"
 optional = true

 [dependencies.satrs-shared]
-version = ">=0.1.3, <=0.2"
+version = "0.2"
+path = "../satrs-shared"
 features = ["serde"]

 [dependencies.satrs-mib-codegen]
--- a/satrs-mib/codegen/Cargo.toml
+++ b/satrs-mib/codegen/Cargo.toml
@@ -28,7 +28,8 @@ features = ["full"]
 trybuild = { version = "1", features = ["diff"] }

 [dev-dependencies.satrs-shared]
-version = ">=0.1.3, <=0.2"
+version = "0.2"
+path = "../../satrs-shared"

 [dev-dependencies.satrs-mib]
 path = ".."
--- a/satrs-minisim/Cargo.toml
+++ b/satrs-minisim/Cargo.toml
@@ -11,7 +11,7 @@ serde_json = "1"
 log = "0.4"
 thiserror = "2"
 fern = "0.7"
-strum = { version = "0.26", features = ["derive"] }
+strum = { version = "0.27", features = ["derive"] }
 num_enum = "0.7"
 humantime = "2"
 tai-time = { version = "0.3", features = ["serde"] }
--- a/satrs-minisim/src/controller.rs
+++ b/satrs-minisim/src/controller.rs
@@ -120,7 +120,7 @@ impl SimController {
    fn handle_ctrl_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
        let sim_ctrl_request = SimCtrlRequest::from_sim_message(request)?;
        if SIM_CTRL_REQ_WIRETAPPING {
-            log::info!("received sim ctrl request: {:?}", sim_ctrl_request);
+            log::info!("received sim ctrl request: {sim_ctrl_request:?}");
        }
        match sim_ctrl_request {
            SimCtrlRequest::Ping => {
@@ -139,7 +139,7 @@ impl SimController {
    ) -> Result<(), SimRequestError> {
        let mgm_request = MgmRequestLis3Mdl::from_sim_message(request)?;
        if MGM_REQ_WIRETAPPING {
-            log::info!("received MGM request: {:?}", mgm_request);
+            log::info!("received MGM request: {mgm_request:?}");
        }
        match mgm_request {
            MgmRequestLis3Mdl::RequestSensorData => {
@@ -160,7 +160,7 @@ impl SimController {
    fn handle_pcdu_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
        let pcdu_request = PcduRequest::from_sim_message(request)?;
        if PCDU_REQ_WIRETAPPING {
-            log::info!("received PCDU request: {:?}", pcdu_request);
+            log::info!("received PCDU request: {pcdu_request:?}");
        }
        match pcdu_request {
            PcduRequest::RequestSwitchInfo => {
@@ -188,7 +188,7 @@ impl SimController {
    fn handle_mgt_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
        let mgt_request = MgtRequest::from_sim_message(request)?;
        if MGT_REQ_WIRETAPPING {
-            log::info!("received MGT request: {:?}", mgt_request);
+            log::info!("received MGT request: {mgt_request:?}");
        }
        match mgt_request {
            MgtRequest::ApplyTorque { duration, dipole } => self
--- a/satrs-minisim/src/main.rs
+++ b/satrs-minisim/src/main.rs
@@ -130,7 +130,7 @@ fn main() {
    let mut udp_server =
        SimUdpServer::new(SIM_CTRL_PORT, request_sender, reply_receiver, 200, None)
            .expect("could not create UDP request server");
-    log::info!("starting UDP server on port {}", SIM_CTRL_PORT);
+    log::info!("starting UDP server on port {SIM_CTRL_PORT}");
    // This thread manages the simulator UDP server.
    let udp_tc_thread = thread::spawn(move || {
        udp_server.run();
--- a/satrs-shared/CHANGELOG.md
+++ b/satrs-shared/CHANGELOG.md
@@ -8,6 +8,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

+# [v0.2.3] 2025-07-22
+
+`spacepackets` range v0.14 to v0.15
+
+# [v0.2.2] 2025-05-10
+
+- Bump to `spacepackests` v0.14
+
 # [v0.2.1] 2024-11-15

 Increased allowed spacepackets to v0.13
@@ -41,3 +49,7 @@ Allow `spacepackets` range starting with v0.10 and v0.11.
 # [v0.1.0] 2024-02-12

 Initial release.
+
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.3...HEAD
+[v0.2.3]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.1...satrs-shared-v0.2.3
+[v0.2.2]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.1...satrs-shared-v0.2.2
--- a/satrs-shared/Cargo.toml
+++ b/satrs-shared/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "satrs-shared"
 description = "Components shared by multiple sat-rs crates"
-version = "0.2.1"
+version = "0.2.3"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -11,6 +11,7 @@ license = "Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
+spacepackets = { version = ">=0.14, <=0.15", default-features = false }

 [dependencies.serde]
 version = "1"
@@ -18,12 +19,9 @@ default-features = false
 optional = true

 [dependencies.defmt]
-version = "0.3"
+version = "1"
 optional = true

-[dependencies.spacepackets]
-version = ">0.9, <=0.13"
-default-features = false

 [features]
 serde = ["dep:serde", "spacepackets/serde"]
--- a/satrs/CHANGELOG.md
+++ b/satrs/CHANGELOG.md
@@ -8,6 +8,26 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

+- Bump `sat-rs` edition to 2024.
+
+## Changed
+
+Some trait renaming to be more in-line with Rust naming conventions.
+
+- `EventTmHookProvider` -> `EventTmHook`
+- `ActiveRequestProvider` -> `ActiveRequest`
+- `EcssTcInMemConversionProvider` -> `CacheAndReadRawEcssTc`
+- `ActiveRequestMapProvider` -> `ActiveRequestStore`
+- `CountdownProvider` -> `Countdown`
+
+# [v0.3.0-alpha.2] 2025-07-22
+
+`satrs-shared` update
+
+# [v0.3.0-alpha.1] 2025-07-22
+
+`spacepackets` range v0.14 to v0.15
+
 # [v0.3.0-alpha.0] 2025-02-18

 `spacepackets` v0.13
@@ -198,3 +218,8 @@ docs-rs hotfix
 # [v0.1.0] 2024-02-12

 Initial release.
+
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.2...HEAD
+[v0.3.0-alpha.2]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.1...satrs-v0.3.0-alpha.2
+[v0.3.0-alpha.1]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.3.0-alpha.0...satrs-v0.3.0-alpha.1
+[v0.3.0-alpha.0]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-v0.2.1...satrs-v0.3.0-alpha.0
--- a/satrs/Cargo.toml
+++ b/satrs/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "satrs"
-version = "0.3.0-alpha.0"
-edition = "2021"
-rust-version = "1.82.0"
+version = "0.3.0-alpha.2"
+edition = "2024"
+rust-version = "1.85.0"
 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/"
+description = "A library collection to build software for remote systems"
+homepage = "https://github.com/us-irs/sat-rs"
 repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
 license = "Apache-2.0"
 keywords = ["no-std", "space", "aerospace"]
@@ -13,29 +13,27 @@ keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]

 [dependencies]
-satrs-shared = ">=0.1.3, <=0.2"
+satrs-shared = { version = "0.2", path = "../satrs-shared" }
+spacepackets = { version = ">=0.14, <=0.15", default-features = false }
+
 delegate = ">0.7, <=0.13"
 paste = "1"
 derive-new = ">=0.6, <=0.7"
-smallvec = "1"
-crc = "3"
 num_enum = { version = ">0.5, <=0.7", default-features = false }
-spacepackets = { version = "0.13", default-features = false }
-cobs = { version = "0.3", default-features = false }
-num-traits = { version = "0.2", default-features = false }
+cobs = { version = "0.4", default-features = false }
 thiserror = { version = "2", default-features = false }

 hashbrown = { version = ">=0.14, <=0.15", optional = true }
 static_cell = { version = "2", optional = true }
 dyn-clone = { version = "1", optional = true }
-heapless = { version = "0.8", optional = true }
+heapless = { version = "0.9", optional = true }
 downcast-rs = { version = "2", default-features = false, optional = true }
 bus = { version = "2.2", optional = true }
 crossbeam-channel = { version = "0.5", default-features = false, optional = true }
 serde = { version = "1", default-features = false, optional = true }
-socket2 = { version = "0.5", features = ["all"], optional = true }
+socket2 = { version = "0.6", features = ["all"], optional = true }
 mio = { version = "1", features = ["os-poll", "net"], optional = true }
-defmt = { version = "0.3", optional = true }
+defmt = { version = "1", optional = true }

 [dev-dependencies]
 serde = "1"
--- a/satrs/README.md
+++ b/satrs/README.md
@@ -4,5 +4,5 @@
 sat-rs
 ======

-This crate contains the primary components of the sat-rs framework.
+This crate contains the primary components of the sat-rs library collection.
 You can find more information on the [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs).
--- a/satrs/src/dev_mgmt.rs
+++ b/satrs/src/dev_mgmt.rs
@@ -1,9 +1,9 @@
 use crate::{
+    ComponentId,
    mode::{ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender},
    mode_tree::{ModeStoreProvider, ModeStoreVec},
    queue::{GenericSendError, GenericTargetedMessagingError},
    request::{GenericMessage, RequestId},
-    ComponentId,
 };
 use core::fmt::Debug;

@@ -270,7 +270,7 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
 #[cfg(test)]
 mod tests {
    use crate::{
-        mode::{tests::ModeReqSenderMock, UNKNOWN_MODE},
+        mode::{UNKNOWN_MODE, tests::ModeReqSenderMock},
        request::MessageMetadata,
    };

--- a/satrs/src/encoding/ccsds.rs
+++ b/satrs/src/encoding/ccsds.rs
@@ -1,6 +1,6 @@
 use spacepackets::{CcsdsPacket, SpHeader};

-use crate::{tmtc::PacketSenderRaw, ComponentId};
+use crate::{ComponentId, tmtc::PacketSenderRaw};

 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SpValidity {
@@ -90,13 +90,13 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
 #[cfg(test)]
 mod tests {
    use spacepackets::{
-        ecss::{tc::PusTcCreator, WritablePusPacket},
        CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader,
+        ecss::tc::PusTcCreator,
    };

-    use crate::{encoding::tests::TcCacher, ComponentId};
+    use crate::{ComponentId, encoding::tests::TcCacher};

-    use super::{parse_buffer_for_ccsds_space_packets, SpValidity, SpacePacketValidator};
+    use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets};

    const PARSER_ID: ComponentId = 0x05;
    const TEST_APID_0: u16 = 0x02;
--- a/satrs/src/encoding/cobs.rs
+++ b/satrs/src/encoding/cobs.rs
@@ -1,4 +1,4 @@
-use crate::{tmtc::PacketSenderRaw, ComponentId};
+use crate::{ComponentId, tmtc::PacketSenderRaw};
 use cobs::{decode_in_place, encode, max_encoding_length};

 /// This function encodes the given packet with COBS and also wraps the encoded packet with
@@ -24,8 +24,8 @@ use cobs::{decode_in_place, encode, max_encoding_length};
 /// assert!(encode_packet_with_cobs(&INVERTED_PACKET, &mut encoding_buf, &mut current_idx));
 /// assert_eq!(encoding_buf[0], 0);
 /// let dec_report = decode_in_place_report(&mut encoding_buf[1..]).expect("decoding failed");
-/// assert_eq!(encoding_buf[1 + dec_report.src_used], 0);
-/// assert_eq!(dec_report.dst_used, 5);
+/// assert_eq!(encoding_buf[1 + dec_report.parsed_size()], 0);
+/// assert_eq!(dec_report.frame_size(), 5);
 /// assert_eq!(current_idx, 16);
 /// ```
 pub fn encode_packet_with_cobs(
@@ -104,8 +104,8 @@ pub(crate) mod tests {
    use cobs::encode;

    use crate::{
-        encoding::tests::{encode_simple_packet, TcCacher, INVERTED_PACKET, SIMPLE_PACKET},
        ComponentId,
+        encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET, TcCacher, encode_simple_packet},
    };

    use super::parse_buffer_for_cobs_encoded_packets;
--- a/satrs/src/encoding/mod.rs
+++ b/satrs/src/encoding/mod.rs
@@ -11,8 +11,8 @@ pub(crate) mod tests {
    use alloc::collections::VecDeque;

    use crate::{
-        tmtc::{PacketAsVec, PacketSenderRaw},
        ComponentId,
+        tmtc::{PacketAsVec, PacketSenderRaw},
    };

    use super::cobs::encode_packet_with_cobs;
--- a/satrs/src/event_man.rs
+++ b/satrs/src/event_man.rs
@@ -71,18 +71,14 @@ pub enum ListenerKey {
 }

 #[derive(Debug)]
-pub struct EventMessage<Event: GenericEvent, ParamProvider: Debug = Params> {
+pub struct EventMessage<Event: GenericEvent, Parameters: Debug = Params> {
    sender_id: ComponentId,
    event: Event,
-    params: Option<ParamProvider>,
+    params: Option<Parameters>,
 }

-impl<Event: GenericEvent, ParamProvider: Debug + Clone> EventMessage<Event, ParamProvider> {
-    pub fn new_generic(
-        sender_id: ComponentId,
-        event: Event,
-        params: Option<&ParamProvider>,
-    ) -> Self {
+impl<Event: GenericEvent, Parameters: Debug + Clone> EventMessage<Event, Parameters> {
+    pub fn new_generic(sender_id: ComponentId, event: Event, params: Option<&Parameters>) -> Self {
        Self {
            sender_id,
            event,
@@ -98,7 +94,7 @@ impl<Event: GenericEvent, ParamProvider: Debug + Clone> EventMessage<Event, Para
        self.event
    }

-    pub fn params(&self) -> Option<&ParamProvider> {
+    pub fn params(&self) -> Option<&Parameters> {
        self.params.as_ref()
    }

@@ -106,7 +102,7 @@ impl<Event: GenericEvent, ParamProvider: Debug + Clone> EventMessage<Event, Para
        Self::new_generic(sender_id, event, None)
    }

-    pub fn new_with_params(sender_id: ComponentId, event: Event, params: &ParamProvider) -> Self {
+    pub fn new_with_params(sender_id: ComponentId, event: Event, params: &Parameters) -> Self {
        Self::new_generic(sender_id, event, Some(params))
    }
 }
@@ -136,7 +132,7 @@ pub trait ListenerMapProvider {
    #[cfg(feature = "alloc")]
    fn get_listeners(&self) -> alloc::vec::Vec<ListenerKey>;
    fn contains_listener(&self, key: &ListenerKey) -> bool;
-    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>>;
+    fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<'_, ComponentId>>;
    fn add_listener(&mut self, key: ListenerKey, listener_id: ComponentId) -> bool;
    fn remove_duplicates(&mut self, key: &ListenerKey);
 }
@@ -162,7 +158,7 @@ pub trait SenderMapProvider<
 ///  * `ListenerMap`: [ListenerMapProvider] which maps listener keys to channel IDs.
 ///  * `EventSender`: [EventSendProvider] contained within the sender map which sends the events.
 ///  * `Event`: The event type. This type must implement the [GenericEvent]. Currently only [EventU32]
-///     and [EventU16] are supported.
+///    and [EventU16] are supported.
 ///  * `ParamProvider`: Auxiliary data which is sent with the event to provide optional context
 ///    information
 pub struct EventManager<
@@ -198,13 +194,13 @@ pub enum EventRoutingError {
 }

 impl<
-        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-        SenderMap: SenderMapProvider<EventSender, Event, ParamProvider>,
-        ListenerMap: ListenerMapProvider,
-        EventSender: EventSendProvider<Event, ParamProvider>,
-        Event: GenericEvent + Copy,
-        ParamProvider: Debug,
-    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSender, Event, ParamProvider>
+    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+    SenderMap: SenderMapProvider<EventSender, Event, ParamProvider>,
+    ListenerMap: ListenerMapProvider,
+    EventSender: EventSendProvider<Event, ParamProvider>,
+    Event: GenericEvent + Copy,
+    ParamProvider: Debug,
+> EventManager<EventReceiver, SenderMap, ListenerMap, EventSender, Event, ParamProvider>
 {
    pub fn remove_duplicates(&mut self, key: &ListenerKey) {
        self.listener_map.remove_duplicates(key)
@@ -229,13 +225,13 @@ impl<
    }
 }
 impl<
-        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-        SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
-        ListenerMap: ListenerMapProvider,
-        EventSenderMap: EventSendProvider<Event, ParamProvider>,
-        Event: GenericEvent + Copy,
-        ParamProvider: Debug,
-    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
+    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+    SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
+    ListenerMap: ListenerMapProvider,
+    EventSenderMap: EventSendProvider<Event, ParamProvider>,
+    Event: GenericEvent + Copy,
+    ParamProvider: Debug,
+> EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
 {
    pub fn new_with_custom_maps(
        event_receiver: EventReceiver,
@@ -267,13 +263,13 @@ impl<
 }

 impl<
-        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-        SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
-        ListenerMap: ListenerMapProvider,
-        EventSenderMap: EventSendProvider<Event, ParamProvider, Error = GenericSendError>,
-        Event: GenericEvent + Copy,
-        ParamProvider: Clone + Debug,
-    > EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
+    EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+    SenderMap: SenderMapProvider<EventSenderMap, Event, ParamProvider>,
+    ListenerMap: ListenerMapProvider,
+    EventSenderMap: EventSendProvider<Event, ParamProvider, Error = GenericSendError>,
+    Event: GenericEvent + Copy,
+    ParamProvider: Clone + Debug,
+> EventManager<EventReceiver, SenderMap, ListenerMap, EventSenderMap, Event, ParamProvider>
 {
    /// This function will use the cached event receiver and try to receive one event.
    /// If an event was received, it will try to route that event to all subscribed event listeners.
@@ -355,11 +351,11 @@ pub mod alloc_mod {
    >;

    impl<
-            EventReceiver: EventReceiveProvider<Event, ParamProvider>,
-            EventSender: EventSendProvider<Event, ParamProvider>,
-            Event: GenericEvent + Copy,
-            ParamProvider: 'static + Debug,
-        >
+        EventReceiver: EventReceiveProvider<Event, ParamProvider>,
+        EventSender: EventSendProvider<Event, ParamProvider>,
+        Event: GenericEvent + Copy,
+        ParamProvider: 'static + Debug,
+    >
        EventManager<
            EventReceiver,
            DefaultSenderMap<EventSender, Event, ParamProvider>,
@@ -402,7 +398,7 @@ pub mod alloc_mod {
            self.listeners.contains_key(key)
        }

-        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<ComponentId>> {
+        fn get_listener_ids(&self, key: &ListenerKey) -> Option<Iter<'_, ComponentId>> {
            self.listeners.get(key).map(|vec| vec.iter())
        }

@@ -437,10 +433,10 @@ pub mod alloc_mod {
    }

    impl<
-            EventSender: EventSendProvider<Event, ParamProvider>,
-            Event: GenericEvent,
-            ParamProvider: Debug,
-        > Default for DefaultSenderMap<EventSender, Event, ParamProvider>
+        EventSender: EventSendProvider<Event, ParamProvider>,
+        Event: GenericEvent,
+        ParamProvider: Debug,
+    > Default for DefaultSenderMap<EventSender, Event, ParamProvider>
    {
        fn default() -> Self {
            Self {
@@ -451,10 +447,10 @@ pub mod alloc_mod {
    }

    impl<
-            EventSender: EventSendProvider<Event, ParamProvider>,
-            Event: GenericEvent,
-            ParamProvider: Debug,
-        > SenderMapProvider<EventSender, Event, ParamProvider>
+        EventSender: EventSendProvider<Event, ParamProvider>,
+        Event: GenericEvent,
+        ParamProvider: Debug,
+    > SenderMapProvider<EventSender, Event, ParamProvider>
        for DefaultSenderMap<EventSender, Event, ParamProvider>
    {
        fn contains_send_event_provider(&self, id: &ComponentId) -> bool {
--- a/satrs/src/events.rs
+++ b/satrs/src/events.rs
@@ -31,9 +31,9 @@ use core::fmt::Debug;
 use core::hash::Hash;
 use core::marker::PhantomData;
 use delegate::delegate;
+use spacepackets::ByteConversionError;
 use spacepackets::ecss::EcssEnumeration;
 use spacepackets::util::{ToBeBytes, UnsignedEnum};
-use spacepackets::ByteConversionError;

 /// Using a type definition allows to change this to u64 in the future more easily
 pub type LargestEventRaw = u32;
@@ -312,11 +312,11 @@ impl EventU32 {
    /// # Parameter
    ///
    /// * `severity`: Each event has a [severity][Severity]. The raw value of the severity will
-    ///        be stored inside the uppermost 2 bits of the raw event ID
+    ///   be stored inside the uppermost 2 bits of the raw event ID
    /// * `group_id`: Related events can be grouped using a group ID. The group ID will occupy the
-    ///        next 14 bits after the severity. Therefore, the size is limited by dec 16383 hex 0x3FFF.
+    ///   next 14 bits after the severity. Therefore, the size is limited by dec 16383 hex 0x3FFF.
    /// * `unique_id`: Each event has a unique 16 bit ID occupying the last 16 bits of the
-    ///       raw event ID
+    ///   raw event ID
    pub fn new_checked(
        severity: Severity,
        group_id: <Self as GenericEvent>::GroupId,
@@ -486,11 +486,11 @@ impl EventU16 {
    /// # Parameter
    ///
    /// * `severity`: Each event has a [severity][Severity]. The raw value of the severity will
-    ///        be stored inside the uppermost 2 bits of the raw event ID
+    ///   be stored inside the uppermost 2 bits of the raw event ID
    /// * `group_id`: Related events can be grouped using a group ID. The group ID will occupy the
-    ///        next 6 bits after the severity. Therefore, the size is limited by dec 63 hex 0x3F.
+    ///   next 6 bits after the severity. Therefore, the size is limited by dec 63 hex 0x3F.
    /// * `unique_id`: Each event has a unique 8 bit ID occupying the last 8 bits of the
-    ///       raw event ID
+    ///   raw event ID
    pub fn new_checked(
        severity: Severity,
        group_id: <Self as GenericEvent>::GroupId,
--- a/satrs/src/executable.rs
+++ b/satrs/src/executable.rs
@@ -39,9 +39,9 @@ pub trait ExecutableWithType: Executable {
 ///
 /// * `executable`: Executable task
 /// * `task_freq`: Optional frequency of task. Required for periodic and fixed cycle tasks.
-///    If [None] is passed, no sleeping will be performed.
+///   If [None] is passed, no sleeping will be performed.
 /// * `op_code`: Operation code which is passed to the executable task
-///    [operation call][Executable::periodic_op]
+///   [operation call][Executable::periodic_op]
 /// * `termination`: Optional termination handler which can cancel threads with a broadcast
 pub fn exec_sched_single<
    T: ExecutableWithType<Error = E> + Send + 'static + ?Sized,
@@ -55,33 +55,35 @@ pub fn exec_sched_single<
    let mut cycle_count = 0;
    thread::Builder::new()
        .name(String::from(executable.task_name()))
-        .spawn(move || loop {
-            if let Some(ref mut terminator) = termination {
-                match terminator.try_recv() {
-                    Ok(_) | Err(TryRecvError::Disconnected) => {
-                        return Ok(OpResult::Ok);
-                    }
-                    Err(TryRecvError::Empty) => (),
-                }
-            }
-            match executable.exec_type() {
-                ExecutionType::OneShot => {
-                    executable.periodic_op(op_code)?;
-                    return Ok(OpResult::Ok);
-                }
-                ExecutionType::Infinite => {
-                    executable.periodic_op(op_code)?;
-                }
-                ExecutionType::Cycles(cycles) => {
-                    executable.periodic_op(op_code)?;
-                    cycle_count += 1;
-                    if cycle_count == cycles {
-                        return Ok(OpResult::Ok);
+        .spawn(move || {
+            loop {
+                if let Some(ref mut terminator) = termination {
+                    match terminator.try_recv() {
+                        Ok(_) | Err(TryRecvError::Disconnected) => {
+                            return Ok(OpResult::Ok);
+                        }
+                        Err(TryRecvError::Empty) => (),
                    }
                }
-            }
-            if let Some(freq) = task_freq {
-                thread::sleep(freq);
+                match executable.exec_type() {
+                    ExecutionType::OneShot => {
+                        executable.periodic_op(op_code)?;
+                        return Ok(OpResult::Ok);
+                    }
+                    ExecutionType::Infinite => {
+                        executable.periodic_op(op_code)?;
+                    }
+                    ExecutionType::Cycles(cycles) => {
+                        executable.periodic_op(op_code)?;
+                        cycle_count += 1;
+                        if cycle_count == cycles {
+                            return Ok(OpResult::Ok);
+                        }
+                    }
+                }
+                if let Some(freq) = task_freq {
+                    thread::sleep(freq);
+                }
            }
        })
 }
@@ -110,51 +112,53 @@ pub fn exec_sched_multi<

    thread::Builder::new()
        .name(String::from(task_name))
-        .spawn(move || loop {
-            if let Some(ref mut terminator) = termination {
-                match terminator.try_recv() {
-                    Ok(_) | Err(TryRecvError::Disconnected) => {
-                        removal_flags.iter_mut().for_each(|x| *x = true);
+        .spawn(move || {
+            loop {
+                if let Some(ref mut terminator) = termination {
+                    match terminator.try_recv() {
+                        Ok(_) | Err(TryRecvError::Disconnected) => {
+                            removal_flags.iter_mut().for_each(|x| *x = true);
+                        }
+                        Err(TryRecvError::Empty) => (),
                    }
-                    Err(TryRecvError::Empty) => (),
                }
-            }
-            for (idx, executable) in executable_vec.iter_mut().enumerate() {
-                match executable.exec_type() {
-                    ExecutionType::OneShot => {
-                        executable.periodic_op(op_code)?;
-                        removal_flags[idx] = true;
-                    }
-                    ExecutionType::Infinite => {
-                        executable.periodic_op(op_code)?;
-                    }
-                    ExecutionType::Cycles(cycles) => {
-                        executable.periodic_op(op_code)?;
-                        cycle_counts[idx] += 1;
-                        if cycle_counts[idx] == cycles {
+                for (idx, executable) in executable_vec.iter_mut().enumerate() {
+                    match executable.exec_type() {
+                        ExecutionType::OneShot => {
+                            executable.periodic_op(op_code)?;
                            removal_flags[idx] = true;
                        }
+                        ExecutionType::Infinite => {
+                            executable.periodic_op(op_code)?;
+                        }
+                        ExecutionType::Cycles(cycles) => {
+                            executable.periodic_op(op_code)?;
+                            cycle_counts[idx] += 1;
+                            if cycle_counts[idx] == cycles {
+                                removal_flags[idx] = true;
+                            }
+                        }
                    }
                }
+                let mut removal_iter = removal_flags.iter();
+                executable_vec.retain(|_| !*removal_iter.next().unwrap());
+                removal_iter = removal_flags.iter();
+                cycle_counts.retain(|_| !*removal_iter.next().unwrap());
+                removal_flags.retain(|&i| !i);
+                if executable_vec.is_empty() {
+                    return Ok(OpResult::Ok);
+                }
+                let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified"));
+                thread::sleep(freq);
            }
-            let mut removal_iter = removal_flags.iter();
-            executable_vec.retain(|_| !*removal_iter.next().unwrap());
-            removal_iter = removal_flags.iter();
-            cycle_counts.retain(|_| !*removal_iter.next().unwrap());
-            removal_flags.retain(|&i| !i);
-            if executable_vec.is_empty() {
-                return Ok(OpResult::Ok);
-            }
-            let freq = task_freq.unwrap_or_else(|| panic!("No task frequency specified"));
-            thread::sleep(freq);
        })
 }

 #[cfg(test)]
 mod tests {
    use super::{
-        exec_sched_multi, exec_sched_single, Executable, ExecutableWithType, ExecutionType,
-        OpResult,
+        Executable, ExecutableWithType, ExecutionType, OpResult, exec_sched_multi,
+        exec_sched_single,
    };
    use bus::Bus;
    use std::boxed::Box;
--- a/satrs/src/hal/std/tcp_cobs_server.rs
+++ b/satrs/src/hal/std/tcp_cobs_server.rs
@@ -13,10 +13,10 @@ use crate::encoding::parse_buffer_for_cobs_encoded_packets;
 use crate::tmtc::PacketSenderRaw;
 use crate::tmtc::PacketSource;

+use crate::ComponentId;
 use crate::hal::std::tcp_server::{
    ConnectionResult, ServerConfig, TcpTcParser, TcpTmSender, TcpTmtcError, TcpTmtcGenericServer,
 };
-use crate::ComponentId;

 use super::tcp_server::HandledConnectionHandler;
 use super::tcp_server::HandledConnectionInfo;
@@ -136,12 +136,12 @@ pub struct TcpTmtcInCobsServer<
 }

 impl<
-        TmSource: PacketSource<Error = TmError>,
-        TcReceiver: PacketSenderRaw<Error = TcError>,
-        HandledConnection: HandledConnectionHandler,
-        TmError: 'static,
-        TcError: 'static,
-    > TcpTmtcInCobsServer<TmSource, TcReceiver, HandledConnection, TmError, TcError>
+    TmSource: PacketSource<Error = TmError>,
+    TcReceiver: PacketSenderRaw<Error = TcError>,
+    HandledConnection: HandledConnectionHandler,
+    TmError: 'static,
+    TcError: 'static,
+> TcpTmtcInCobsServer<TmSource, TcReceiver, HandledConnection, TmError, TcError>
 {
    /// Create a new TCP TMTC server which exchanges TMTC packets encoded with
    /// [COBS protocol](https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing).
@@ -150,9 +150,9 @@ 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.
+    ///   then sent back to the client.
    /// * `tc_receiver` - Any received telecommands which were decoded successfully will be
-    ///     forwarded to this TC receiver.
+    ///   forwarded to this TC receiver.
    pub fn new(
        cfg: ServerConfig,
        tm_source: TmSource,
@@ -206,14 +206,14 @@ mod tests {
    };

    use crate::{
+        ComponentId,
        encoding::tests::{INVERTED_PACKET, SIMPLE_PACKET},
        hal::std::tcp_server::{
-            tests::{ConnectionFinishedHandler, SyncTmSource},
            ConnectionResult, ServerConfig,
+            tests::{ConnectionFinishedHandler, SyncTmSource},
        },
        queue::GenericSendError,
        tmtc::PacketAsVec,
-        ComponentId,
    };
    use alloc::sync::Arc;
    use cobs::encode;
@@ -377,13 +377,13 @@ mod tests {
                current_idx += 1;
                let mut dec_report = cobs::decode_in_place_report(&mut read_buf[current_idx..])
                    .expect("COBS decoding failed");
-                assert_eq!(dec_report.dst_used, 5);
+                assert_eq!(dec_report.frame_size(), 5);
                // Skip first sentinel byte.
                assert_eq!(
                    &read_buf[current_idx..current_idx + INVERTED_PACKET.len()],
                    &INVERTED_PACKET
                );
-                current_idx += dec_report.src_used;
+                current_idx += dec_report.parsed_size();
                // End sentinel.
                assert_eq!(read_buf[current_idx], 0, "invalid sentinel end byte");
                current_idx += 1;
@@ -393,13 +393,13 @@ mod tests {
                current_idx += 1;
                dec_report = cobs::decode_in_place_report(&mut read_buf[current_idx..])
                    .expect("COBS decoding failed");
-                assert_eq!(dec_report.dst_used, 5);
+                assert_eq!(dec_report.frame_size(), 5);
                // Skip first sentinel byte.
                assert_eq!(
                    &read_buf[current_idx..current_idx + SIMPLE_PACKET.len()],
                    &SIMPLE_PACKET
                );
-                current_idx += dec_report.src_used;
+                current_idx += dec_report.parsed_size();
                // End sentinel.
                assert_eq!(read_buf[current_idx], 0);
                break;
@@ -435,17 +435,19 @@ mod tests {
            generic_tmtc_server(&auto_port_addr, tc_sender.clone(), tm_source, None);
        let start = Instant::now();
        // Call the connection handler in separate thread, does block.
-        let thread_jh = thread::spawn(move || loop {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
-            if result.is_err() {
-                panic!("handling connection failed: {:?}", result.unwrap_err());
-            }
-            let result = result.unwrap();
-            if result == ConnectionResult::AcceptTimeout {
-                break;
-            }
-            if Instant::now() - start > Duration::from_millis(100) {
-                panic!("regular stop signal handling failed");
+        let thread_jh = thread::spawn(move || {
+            loop {
+                let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+                if result.is_err() {
+                    panic!("handling connection failed: {:?}", result.unwrap_err());
+                }
+                let result = result.unwrap();
+                if result == ConnectionResult::AcceptTimeout {
+                    break;
+                }
+                if Instant::now() - start > Duration::from_millis(100) {
+                    panic!("regular stop signal handling failed");
+                }
            }
        });
        thread_jh.join().expect("thread join failed");
@@ -469,20 +471,22 @@ mod tests {
        let stop_signal_copy = stop_signal.clone();
        let start = Instant::now();
        // Call the connection handler in separate thread, does block.
-        let thread_jh = thread::spawn(move || loop {
-            let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
-            if result.is_err() {
-                panic!("handling connection failed: {:?}", result.unwrap_err());
-            }
-            let result = result.unwrap();
-            if result == ConnectionResult::AcceptTimeout {
-                panic!("unexpected accept timeout");
-            }
-            if stop_signal_copy.load(Ordering::Relaxed) {
-                break;
-            }
-            if Instant::now() - start > Duration::from_millis(100) {
-                panic!("regular stop signal handling failed");
+        let thread_jh = thread::spawn(move || {
+            loop {
+                let result = tcp_server.handle_all_connections(Some(Duration::from_millis(20)));
+                if result.is_err() {
+                    panic!("handling connection failed: {:?}", result.unwrap_err());
+                }
+                let result = result.unwrap();
+                if result == ConnectionResult::AcceptTimeout {
+                    panic!("unexpected accept timeout");
+                }
+                if stop_signal_copy.load(Ordering::Relaxed) {
+                    break;
+                }
+                if Instant::now() - start > Duration::from_millis(100) {
+                    panic!("regular stop signal handling failed");
+                }
            }
        });
        // We connect but do not do anything.
--- a/satrs/src/hal/std/tcp_server.rs
+++ b/satrs/src/hal/std/tcp_server.rs
@@ -11,8 +11,8 @@ use std::io::{self, Read};
 use std::net::SocketAddr;
 use std::thread;

-use crate::tmtc::{PacketSenderRaw, PacketSource};
 use crate::ComponentId;
+use crate::tmtc::{PacketSenderRaw, PacketSource};
 use thiserror::Error;

 // Re-export the TMTC in COBS server.
@@ -25,22 +25,22 @@ pub use crate::hal::std::tcp_spacepackets_server::{SpacepacketsTmSender, TcpSpac
 ///
 /// * `addr` - Address of the TCP 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.
+///   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 [PacketSource] and
-///     encoding of that data. This buffer should at large enough to hold the maximum expected
-///     TM size read from the packet source.
+///   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
-///     the client. It is recommended to make this buffer larger to allow reading multiple
-///     consecutive packets as well, for example by using common buffer sizes like 4096 or 8192
-///     byte. The buffer should at the very least be large enough to hold the maximum expected
-///     telecommand size.
+///   the client. It is recommended to make this buffer larger to allow reading multiple
+///   consecutive packets as well, for example by using common buffer sizes like 4096 or 8192
+///   byte. The buffer should at the very least be large enough to hold the maximum expected
+///   telecommand size.
 /// * `reuse_addr` - Can be used to set the `SO_REUSEADDR` option on the raw socket. This is
-///     especially useful if the address and port are static for the server. Set to false by
-///     default.
+///   especially useful if the address and port are static for the server. Set to false by
+///   default.
 /// * `reuse_port` - Can be used to set the `SO_REUSEPORT` option on the raw socket. This is
-///     especially useful if the address and port are static for the server. Set to false by
-///     default.
+///   especially useful if the address and port are static for the server. Set to false by
+///   default.
 #[derive(Debug, Copy, Clone)]
 pub struct ServerConfig {
    pub id: ComponentId,
@@ -187,14 +187,14 @@ pub struct TcpTmtcGenericServer<
 }

 impl<
-        TmSource: PacketSource<Error = TmError>,
-        TcSender: PacketSenderRaw<Error = TcSendError>,
-        TmSender: TcpTmSender<TmError, TcSendError>,
-        TcParser: TcpTcParser<TmError, TcSendError>,
-        HandledConnection: HandledConnectionHandler,
-        TmError: 'static,
-        TcSendError: 'static,
-    >
+    TmSource: PacketSource<Error = TmError>,
+    TcSender: PacketSenderRaw<Error = TcSendError>,
+    TmSender: TcpTmSender<TmError, TcSendError>,
+    TcParser: TcpTcParser<TmError, TcSendError>,
+    HandledConnection: HandledConnectionHandler,
+    TmError: 'static,
+    TcSendError: 'static,
+>
    TcpTmtcGenericServer<
        TmSource,
        TcSender,
@@ -211,12 +211,12 @@ impl<
    ///
    /// * `cfg` - Configuration of the server.
    /// * `tc_parser` - Parser which extracts telecommands from the raw bytestream received from
-    ///    the client.
+    ///   the client.
    /// * `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.
+    ///   then sent back to the client.
    /// * `tc_sender` - Any received telecommand which was decoded successfully will be forwarded
-    ///     using this TC sender.
+    ///   using this TC sender.
    /// * `stop_signal` - Can be used to stop the server even if a connection is ongoing.
    pub fn new(
        cfg: ServerConfig,
--- a/satrs/src/hal/std/tcp_spacepackets_server.rs
+++ b/satrs/src/hal/std/tcp_spacepackets_server.rs
@@ -5,9 +5,9 @@ use mio::net::{TcpListener, TcpStream};
 use std::{io::Write, net::SocketAddr};

 use crate::{
+    ComponentId,
    encoding::{ccsds::SpacePacketValidator, parse_buffer_for_ccsds_space_packets},
    tmtc::{PacketSenderRaw, PacketSource},
-    ComponentId,
 };

 use super::tcp_server::{
@@ -107,28 +107,28 @@ pub struct TcpSpacepacketsServer<
 }

 impl<
-        TmSource: PacketSource<Error = TmError>,
-        TcSender: PacketSenderRaw<Error = TcError>,
-        Validator: SpacePacketValidator,
-        HandledConnection: HandledConnectionHandler,
-        TmError: 'static,
-        TcError: 'static,
-    > TcpSpacepacketsServer<TmSource, TcSender, Validator, HandledConnection, TmError, TcError>
+    TmSource: PacketSource<Error = TmError>,
+    TcSender: PacketSenderRaw<Error = TcError>,
+    Validator: SpacePacketValidator,
+    HandledConnection: HandledConnectionHandler,
+    TmError: 'static,
+    TcError: 'static,
+> TcpSpacepacketsServer<TmSource, TcSender, Validator, HandledConnection, TmError, TcError>
 {
    ///
    /// ## Parameter
    ///
    /// * `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.
+    ///   then sent back to the client.
    /// * `tc_sender` - Any received telecommands which were decoded successfully will be
-    ///     forwarded using this [PacketSenderRaw].
+    ///   forwarded using this [PacketSenderRaw].
    /// * `validator` - Used to determine the space packets relevant for further processing and
-    ///    to detect broken space packets.
+    ///   to detect broken space packets.
    /// * `handled_connection_hook` - Called to notify the user about a succesfully handled
-    ///    connection.
+    ///   connection.
    /// * `stop_signal` - Can be used to shut down the TCP server even for longer running
-    ///    connections.
+    ///   connections.
    pub fn new(
        cfg: ServerConfig,
        tm_source: TmSource,
@@ -185,19 +185,19 @@ mod tests {
    use alloc::sync::Arc;
    use hashbrown::HashSet;
    use spacepackets::{
-        ecss::{tc::PusTcCreator, WritablePusPacket},
        CcsdsPacket, PacketId, SpHeader,
+        ecss::{WritablePusPacket, tc::PusTcCreator},
    };

    use crate::{
+        ComponentId,
        encoding::ccsds::{SpValidity, SpacePacketValidator},
        hal::std::tcp_server::{
-            tests::{ConnectionFinishedHandler, SyncTmSource},
            ConnectionResult, ServerConfig,
+            tests::{ConnectionFinishedHandler, SyncTmSource},
        },
        queue::GenericSendError,
        tmtc::PacketAsVec,
-        ComponentId,
    };

    use super::TcpSpacepacketsServer;
--- a/satrs/src/hal/std/udp_server.rs
+++ b/satrs/src/hal/std/udp_server.rs
@@ -1,6 +1,6 @@
 //! Generic UDP TC server.
-use crate::tmtc::PacketSenderRaw;
 use crate::ComponentId;
+use crate::tmtc::PacketSenderRaw;
 use core::fmt::Debug;
 use std::io::{self, ErrorKind};
 use std::net::{SocketAddr, ToSocketAddrs, UdpSocket};
@@ -105,7 +105,7 @@ impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>
                    Err(ReceiveResult::NothingReceived)
                } else {
                    Err(e.into())
-                }
+                };
            }
        };
        let (num_bytes, from) = res;
@@ -123,14 +123,13 @@ impl<TcSender: PacketSenderRaw<Error = SendError>, SendError: Debug + 'static>

 #[cfg(test)]
 mod tests {
+    use crate::ComponentId;
    use crate::hal::std::udp_server::{ReceiveResult, UdpTcServer};
    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 spacepackets::ecss::tc::PusTcCreator;
    use std::collections::VecDeque;
    use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
    use std::vec::Vec;
--- a/satrs/src/mode.rs
+++ b/satrs/src/mode.rs
@@ -11,11 +11,11 @@ pub use alloc_mod::*;
 pub use std_mod::*;

 use crate::{
+    ComponentId,
    queue::{GenericReceiveError, GenericSendError},
    request::{
        GenericMessage, MessageMetadata, MessageReceiverProvider, MessageReceiverWithId, RequestId,
    },
-    ComponentId,
 };

 pub type Mode = u32;
@@ -257,7 +257,7 @@ pub trait ModeRequestHandler: ModeProvider {

 pub trait ModeReplyReceiver {
    fn try_recv_mode_reply(&self)
-        -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError>;
+    -> Result<Option<GenericMessage<ModeReply>>, GenericReceiveError>;
 }

 impl<R: MessageReceiverProvider<ModeReply>> ModeReplyReceiver
@@ -309,12 +309,11 @@ pub mod alloc_mod {
    }

    impl<
-            From,
-            Sender: MessageSenderProvider<ModeReply>,
-            Receiver: MessageReceiverProvider<From>,
-            SenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
-        > ModeReplySender
-        for MessageSenderAndReceiver<ModeReply, From, Sender, Receiver, SenderStore>
+        From,
+        Sender: MessageSenderProvider<ModeReply>,
+        Receiver: MessageReceiverProvider<From>,
+        SenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
+    > ModeReplySender for MessageSenderAndReceiver<ModeReply, From, Sender, Receiver, SenderStore>
    {
        fn local_channel_id(&self) -> ComponentId {
            self.local_channel_id_generic()
@@ -334,12 +333,11 @@ pub mod alloc_mod {
    }

    impl<
-            To,
-            Sender: MessageSenderProvider<To>,
-            Receiver: MessageReceiverProvider<ModeReply>,
-            SenderStore: MessageSenderStoreProvider<To, Sender>,
-        > ModeReplyReceiver
-        for MessageSenderAndReceiver<To, ModeReply, Sender, Receiver, SenderStore>
+        To,
+        Sender: MessageSenderProvider<To>,
+        Receiver: MessageReceiverProvider<ModeReply>,
+        SenderStore: MessageSenderStoreProvider<To, Sender>,
+    > ModeReplyReceiver for MessageSenderAndReceiver<To, ModeReply, Sender, Receiver, SenderStore>
    {
        fn try_recv_mode_reply(
            &self,
@@ -349,15 +347,15 @@ pub mod alloc_mod {
    }

    impl<
-            Request,
-            ReqSender: MessageSenderProvider<Request>,
-            ReqReceiver: MessageReceiverProvider<Request>,
-            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
-            Reply,
-            ReplySender: MessageSenderProvider<Reply>,
-            ReplyReceiver: MessageReceiverProvider<Reply>,
-            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
-        >
+        Request,
+        ReqSender: MessageSenderProvider<Request>,
+        ReqReceiver: MessageReceiverProvider<Request>,
+        ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+    >
        RequestAndReplySenderAndReceiver<
            Request,
            ReqSender,
@@ -376,14 +374,14 @@ pub mod alloc_mod {
    }

    impl<
-            Request,
-            ReqSender: MessageSenderProvider<Request>,
-            ReqReceiver: MessageReceiverProvider<Request>,
-            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
-            ReplySender: MessageSenderProvider<ModeReply>,
-            ReplyReceiver: MessageReceiverProvider<ModeReply>,
-            ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
-        > ModeReplySender
+        Request,
+        ReqSender: MessageSenderProvider<Request>,
+        ReqReceiver: MessageReceiverProvider<Request>,
+        ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+        ReplySender: MessageSenderProvider<ModeReply>,
+        ReplyReceiver: MessageReceiverProvider<ModeReply>,
+        ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
+    > ModeReplySender
        for RequestAndReplySenderAndReceiver<
            Request,
            ReqSender,
@@ -413,14 +411,14 @@ pub mod alloc_mod {
    }

    impl<
-            Request,
-            ReqSender: MessageSenderProvider<Request>,
-            ReqReceiver: MessageReceiverProvider<Request>,
-            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
-            ReplySender: MessageSenderProvider<ModeReply>,
-            ReplyReceiver: MessageReceiverProvider<ModeReply>,
-            ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
-        > ModeReplyReceiver
+        Request,
+        ReqSender: MessageSenderProvider<Request>,
+        ReqReceiver: MessageReceiverProvider<Request>,
+        ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+        ReplySender: MessageSenderProvider<ModeReply>,
+        ReplyReceiver: MessageReceiverProvider<ModeReply>,
+        ReplySenderStore: MessageSenderStoreProvider<ModeReply, ReplySender>,
+    > ModeReplyReceiver
        for RequestAndReplySenderAndReceiver<
            Request,
            ReqSender,
@@ -444,10 +442,10 @@ pub mod alloc_mod {
        MessageSenderAndReceiver<ModeReply, ModeRequest, Sender, Receiver, ReplySenderStore>;

    impl<
-            Sender: MessageSenderProvider<ModeReply>,
-            Receiver: MessageReceiverProvider<ModeRequest>,
-            ReplySenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
-        > ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore>
+        Sender: MessageSenderProvider<ModeReply>,
+        Receiver: MessageReceiverProvider<ModeRequest>,
+        ReplySenderStore: MessageSenderStoreProvider<ModeReply, Sender>,
+    > ModeRequestHandlerInterface<Sender, Receiver, ReplySenderStore>
    {
        pub fn try_recv_mode_request(
            &self,
@@ -474,10 +472,10 @@ pub mod alloc_mod {
        MessageSenderAndReceiver<ModeRequest, ModeReply, Sender, Receiver, RequestSenderStore>;

    impl<
-            Sender: MessageSenderProvider<ModeRequest>,
-            Receiver: MessageReceiverProvider<ModeReply>,
-            RequestSenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
-        > ModeRequestorInterface<Sender, Receiver, RequestSenderStore>
+        Sender: MessageSenderProvider<ModeRequest>,
+        Receiver: MessageReceiverProvider<ModeReply>,
+        RequestSenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
+    > ModeRequestorInterface<Sender, Receiver, RequestSenderStore>
    {
        pub fn try_recv_mode_reply(
            &self,
@@ -531,11 +529,11 @@ pub mod alloc_mod {
    }

    impl<
-            To,
-            Sender: MessageSenderProvider<To>,
-            Receiver: MessageReceiverProvider<ModeRequest>,
-            SenderStore: MessageSenderStoreProvider<To, Sender>,
-        > ModeRequestReceiver
+        To,
+        Sender: MessageSenderProvider<To>,
+        Receiver: MessageReceiverProvider<ModeRequest>,
+        SenderStore: MessageSenderStoreProvider<To, Sender>,
+    > ModeRequestReceiver
        for MessageSenderAndReceiver<To, ModeRequest, Sender, Receiver, SenderStore>
    {
        fn try_recv_mode_request(
@@ -546,11 +544,11 @@ pub mod alloc_mod {
    }

    impl<
-            From,
-            Sender: MessageSenderProvider<ModeRequest>,
-            Receiver: MessageReceiverProvider<From>,
-            SenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
-        > ModeRequestSender
+        From,
+        Sender: MessageSenderProvider<ModeRequest>,
+        Receiver: MessageReceiverProvider<From>,
+        SenderStore: MessageSenderStoreProvider<ModeRequest, Sender>,
+    > ModeRequestSender
        for MessageSenderAndReceiver<ModeRequest, From, Sender, Receiver, SenderStore>
    {
        fn local_channel_id(&self) -> ComponentId {
@@ -572,14 +570,14 @@ pub mod alloc_mod {
    }

    impl<
-            ReqSender: MessageSenderProvider<ModeRequest>,
-            ReqReceiver: MessageReceiverProvider<ModeRequest>,
-            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
-            Reply,
-            ReplySender: MessageSenderProvider<Reply>,
-            ReplyReceiver: MessageReceiverProvider<Reply>,
-            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
-        >
+        ReqSender: MessageSenderProvider<ModeRequest>,
+        ReqReceiver: MessageReceiverProvider<ModeRequest>,
+        ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+    >
        RequestAndReplySenderAndReceiver<
            ModeRequest,
            ReqSender,
@@ -598,14 +596,14 @@ pub mod alloc_mod {
    }

    impl<
-            ReqSender: MessageSenderProvider<ModeRequest>,
-            ReqReceiver: MessageReceiverProvider<ModeRequest>,
-            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
-            Reply,
-            ReplySender: MessageSenderProvider<Reply>,
-            ReplyReceiver: MessageReceiverProvider<Reply>,
-            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
-        > ModeRequestSender
+        ReqSender: MessageSenderProvider<ModeRequest>,
+        ReqReceiver: MessageReceiverProvider<ModeRequest>,
+        ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+    > ModeRequestSender
        for RequestAndReplySenderAndReceiver<
            ModeRequest,
            ReqSender,
@@ -636,14 +634,14 @@ pub mod alloc_mod {
    }

    impl<
-            ReqSender: MessageSenderProvider<ModeRequest>,
-            ReqReceiver: MessageReceiverProvider<ModeRequest>,
-            ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
-            Reply,
-            ReplySender: MessageSenderProvider<Reply>,
-            ReplyReceiver: MessageReceiverProvider<Reply>,
-            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
-        > ModeRequestReceiver
+        ReqSender: MessageSenderProvider<ModeRequest>,
+        ReqReceiver: MessageReceiverProvider<ModeRequest>,
+        ReqSenderStore: MessageSenderStoreProvider<ModeRequest, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+    > ModeRequestReceiver
        for RequestAndReplySenderAndReceiver<
            ModeRequest,
            ReqSender,
@@ -726,7 +724,7 @@ pub(crate) mod tests {
    use core::cell::RefCell;
    use std::collections::VecDeque;

-    use crate::{request::RequestId, ComponentId};
+    use crate::{ComponentId, request::RequestId};

    use super::*;

--- a/satrs/src/mode_tree.rs
+++ b/satrs/src/mode_tree.rs
@@ -2,9 +2,9 @@ use alloc::vec::Vec;
 use hashbrown::HashMap;

 use crate::{
+    ComponentId,
    mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, Submode},
    request::MessageSenderProvider,
-    ComponentId,
 };

 #[cfg(feature = "alloc")]
--- a/satrs/src/params.rs
+++ b/satrs/src/params.rs
@@ -47,10 +47,10 @@ use crate::pool::PoolAddr;
 use core::fmt::Debug;
 use core::mem::size_of;
 use paste::paste;
-use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
+use spacepackets::ByteConversionError;
+use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumU64};
 pub use spacepackets::util::ToBeBytes;
 use spacepackets::util::UnsignedEnum;
-use spacepackets::ByteConversionError;

 #[cfg(feature = "alloc")]
 use alloc::string::{String, ToString};
--- a/satrs/src/pool.rs
+++ b/satrs/src/pool.rs
@@ -222,7 +222,7 @@ impl Error for PoolError {
    }
 }

-/// Generic trait for pool providers which provide memory pools for variable sized data.
+/// Generic trait for pool providers which provide memory pools for variable sized packet data.
 ///
 /// It specifies a basic API to [Self::add], [Self::modify], [Self::read] and [Self::delete] data
 /// in the store at its core. The API was designed so internal optimizations can be performed
@@ -250,7 +250,7 @@ pub trait PoolProvider {
    /// call the user-provided closure and pass a mutable reference to the memory block
    /// to the closure. This allows the user to modify the memory block.
    fn modify<U: FnMut(&mut [u8])>(&mut self, addr: &PoolAddr, updater: U)
-        -> Result<(), PoolError>;
+    -> Result<(), PoolError>;

    /// The provider should copy the data from the memory block to the user-provided buffer if
    /// it exists.
@@ -281,7 +281,7 @@ pub trait PoolProviderWithGuards: PoolProvider {
    /// This can prevent memory leaks. Users can read the data and release the guard
    /// if the data in the store is valid for further processing. If the data is faulty, no
    /// manual deletion is necessary when returning from a processing function prematurely.
-    fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<Self>;
+    fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self>;

    /// This function behaves like [PoolProvider::modify], but consumes the provided
    /// address and returns a RAII conformant guard object.
@@ -291,7 +291,7 @@ pub trait PoolProviderWithGuards: PoolProvider {
    /// This can prevent memory leaks. Users can read (and modify) the data and release the guard
    /// if the data in the store is valid for further processing. If the data is faulty, no
    /// manual deletion is necessary when returning from a processing function prematurely.
-    fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<Self>;
+    fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self>;
 }

 pub struct PoolGuard<'a, MemProvider: PoolProvider + ?Sized> {
@@ -510,11 +510,11 @@ pub mod heapless_mod {
        ///
        /// * `subpool_memory` - Static memory for a particular subpool to store the actual data.
        /// * `sizes_list` - Static sizes list structure to store the size of the data which is
-        ///    actually stored.
+        ///   actually stored.
        /// * `num_blocks ` - The number of memory blocks inside the subpool.
        /// * `set_sizes_list_to_all_free` - If this is set to true, the method will take care
-        ///    of setting all values in the sizes list to [super::STORE_FREE]. This does not have
-        ///    to be done if the user initializes the sizes list to that value themselves.
+        ///   of setting all values in the sizes list to [super::STORE_FREE]. This does not have
+        ///   to be done if the user initializes the sizes list to that value themselves.
        pub fn grow(
            &mut self,
            subpool_memory: &'static mut [u8],
@@ -602,7 +602,7 @@ pub mod heapless_mod {
                if i < start_at_subpool as usize {
                    continue;
                }
-                if pool_cfg.block_size as usize >= req_size {
+                if pool_cfg.block_size >= req_size {
                    return Ok(i as u16);
                }
            }
@@ -638,7 +638,7 @@ pub mod heapless_mod {

        fn raw_pos(&self, addr: &StaticPoolAddr) -> Option<usize> {
            let (pool_cfg, _) = self.pool.get(addr.pool_idx as usize)?;
-            Some(addr.packet_idx as usize * pool_cfg.block_size as usize)
+            Some(addr.packet_idx as usize * pool_cfg.block_size)
        }
    }

@@ -707,7 +707,7 @@ pub mod heapless_mod {
            let subpool_cfg = self.pool.get(addr.pool_idx as usize).unwrap().0;
            let raw_pos = self.raw_pos(&addr).unwrap();
            let block = &mut self.pool.get_mut(addr.pool_idx as usize).unwrap().1
-                [raw_pos..raw_pos + subpool_cfg.block_size as usize];
+                [raw_pos..raw_pos + subpool_cfg.block_size];
            let size_list = self.sizes_lists.get_mut(addr.pool_idx as usize).unwrap();
            size_list[addr.packet_idx as usize] = STORE_FREE;
            block.fill(0);
@@ -742,11 +742,11 @@ pub mod heapless_mod {
    impl<const MAX_NUM_SUBPOOLS: usize> PoolProviderWithGuards
        for StaticHeaplessMemoryPool<MAX_NUM_SUBPOOLS>
    {
-        fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<Self> {
+        fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self> {
            PoolRwGuard::new(self, addr)
        }

-        fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<Self> {
+        fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self> {
            PoolGuard::new(self, addr)
        }
    }
@@ -770,11 +770,11 @@ mod alloc_mod {
    /// # Parameters
    ///
    /// * `cfg` - Vector of tuples which represent a subpool. The first entry in the tuple specifies
-    ///     the number of memory blocks in the subpool, the second entry the size of the blocks
+    ///   the number of memory blocks in the subpool, the second entry the size of the blocks
    /// * `spill_to_higher_subpools` - Specifies whether data will be spilled to higher subpools
-    ///     if the next fitting subpool is full. This is useful to ensure the pool remains useful
-    ///     for all data sizes as long as possible. However, an undesirable side-effect might be
-    ///     the chocking of larger subpools by underdimensioned smaller subpools.
+    ///   if the next fitting subpool is full. This is useful to ensure the pool remains useful
+    ///   for all data sizes as long as possible. However, an undesirable side-effect might be
+    ///   the chocking of larger subpools by underdimensioned smaller subpools.
    #[derive(Debug, Clone)]
    pub struct StaticPoolConfig {
        cfg: Vec<SubpoolConfig>,
@@ -1058,11 +1058,11 @@ mod alloc_mod {
    }

    impl PoolProviderWithGuards for StaticMemoryPool {
-        fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<Self> {
+        fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self> {
            PoolRwGuard::new(self, addr)
        }

-        fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<Self> {
+        fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self> {
            PoolGuard::new(self, addr)
        }
    }
@@ -1307,9 +1307,11 @@ mod tests {
        let addr = pool_provider.add(&test_buf).expect("Adding data failed");
        let read_guard = PoolGuard::new(pool_provider, addr);
        drop(read_guard);
-        assert!(!pool_provider
-            .has_element_at(&addr)
-            .expect("Invalid address"));
+        assert!(
+            !pool_provider
+                .has_element_at(&addr)
+                .expect("Invalid address")
+        );
    }

    fn generic_test_pool_guard_deletion(pool_provider: &mut impl PoolProviderWithGuards) {
@@ -1317,9 +1319,11 @@ mod tests {
        let addr = pool_provider.add(&test_buf).expect("Adding data failed");
        let read_guard = pool_provider.read_with_guard(addr);
        drop(read_guard);
-        assert!(!pool_provider
-            .has_element_at(&addr)
-            .expect("Invalid address"));
+        assert!(
+            !pool_provider
+                .has_element_at(&addr)
+                .expect("Invalid address")
+        );
    }

    fn generic_test_pool_guard_with_release(pool_provider: &mut impl PoolProviderWithGuards) {
@@ -1328,9 +1332,11 @@ mod tests {
        let mut read_guard = PoolGuard::new(pool_provider, addr);
        read_guard.release();
        drop(read_guard);
-        assert!(pool_provider
-            .has_element_at(&addr)
-            .expect("Invalid address"));
+        assert!(
+            pool_provider
+                .has_element_at(&addr)
+                .expect("Invalid address")
+        );
    }

    fn generic_test_pool_modify_guard_man_creation(
@@ -1341,9 +1347,11 @@ mod tests {
        let mut rw_guard = PoolRwGuard::new(pool_provider, addr);
        rw_guard.update(&mut |_| {}).expect("modify failed");
        drop(rw_guard);
-        assert!(!pool_provider
-            .has_element_at(&addr)
-            .expect("Invalid address"));
+        assert!(
+            !pool_provider
+                .has_element_at(&addr)
+                .expect("Invalid address")
+        );
    }

    fn generic_test_pool_modify_guard(pool_provider: &mut impl PoolProviderWithGuards) {
@@ -1352,9 +1360,11 @@ mod tests {
        let mut rw_guard = pool_provider.modify_with_guard(addr);
        rw_guard.update(&mut |_| {}).expect("modify failed");
        drop(rw_guard);
-        assert!(!pool_provider
-            .has_element_at(&addr)
-            .expect("Invalid address"));
+        assert!(
+            !pool_provider
+                .has_element_at(&addr)
+                .expect("Invalid address")
+        );
    }

    fn generic_modify_pool_index_above_0(pool_provider: &mut impl PoolProvider) {
@@ -1654,30 +1664,36 @@ mod tests {
        fn small_heapless_pool() -> StaticHeaplessMemoryPool<3> {
            let mut heapless_pool: StaticHeaplessMemoryPool<3> =
                StaticHeaplessMemoryPool::new(false);
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_1.take(),
-                    unsafe { &mut *SUBPOOL_1_SIZES.lock().unwrap().get() },
-                    SUBPOOL_1_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_2.take(),
-                    SUBPOOL_2_SIZES.take(),
-                    SUBPOOL_2_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_3.take(),
-                    SUBPOOL_3_SIZES.take(),
-                    SUBPOOL_3_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_1.take(),
+                        unsafe { &mut *SUBPOOL_1_SIZES.lock().unwrap().get() },
+                        SUBPOOL_1_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_2.take(),
+                        SUBPOOL_2_SIZES.take(),
+                        SUBPOOL_2_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_3.take(),
+                        SUBPOOL_3_SIZES.take(),
+                        SUBPOOL_3_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
            heapless_pool
        }

@@ -1793,22 +1809,26 @@ mod tests {
        fn test_spills_to_higher_subpools() {
            let mut heapless_pool: StaticHeaplessMemoryPool<2> =
                StaticHeaplessMemoryPool::new(true);
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_2.take(),
-                    SUBPOOL_2_SIZES.take(),
-                    SUBPOOL_2_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_4.take(),
-                    SUBPOOL_4_SIZES.take(),
-                    SUBPOOL_4_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_2.take(),
+                        SUBPOOL_2_SIZES.take(),
+                        SUBPOOL_2_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_4.take(),
+                        SUBPOOL_4_SIZES.take(),
+                        SUBPOOL_4_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
            generic_test_spills_to_higher_subpools(&mut heapless_pool);
        }

@@ -1816,22 +1836,26 @@ mod tests {
        fn test_spillage_fails_as_well() {
            let mut heapless_pool: StaticHeaplessMemoryPool<2> =
                StaticHeaplessMemoryPool::new(true);
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_5.take(),
-                    SUBPOOL_5_SIZES.take(),
-                    SUBPOOL_5_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_3.take(),
-                    SUBPOOL_3_SIZES.take(),
-                    SUBPOOL_3_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_5.take(),
+                        SUBPOOL_5_SIZES.take(),
+                        SUBPOOL_5_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_3.take(),
+                        SUBPOOL_3_SIZES.take(),
+                        SUBPOOL_3_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
            generic_test_spillage_fails_as_well(&mut heapless_pool);
        }

@@ -1839,30 +1863,36 @@ mod tests {
        fn test_spillage_works_across_multiple_subpools() {
            let mut heapless_pool: StaticHeaplessMemoryPool<3> =
                StaticHeaplessMemoryPool::new(true);
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_5.take(),
-                    SUBPOOL_5_SIZES.take(),
-                    SUBPOOL_5_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_6.take(),
-                    SUBPOOL_6_SIZES.take(),
-                    SUBPOOL_6_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_3.take(),
-                    SUBPOOL_3_SIZES.take(),
-                    SUBPOOL_3_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_5.take(),
+                        SUBPOOL_5_SIZES.take(),
+                        SUBPOOL_5_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_6.take(),
+                        SUBPOOL_6_SIZES.take(),
+                        SUBPOOL_6_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_3.take(),
+                        SUBPOOL_3_SIZES.take(),
+                        SUBPOOL_3_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
            generic_test_spillage_works_across_multiple_subpools(&mut heapless_pool);
        }

@@ -1870,30 +1900,36 @@ mod tests {
        fn test_spillage_fails_across_multiple_subpools() {
            let mut heapless_pool: StaticHeaplessMemoryPool<3> =
                StaticHeaplessMemoryPool::new(true);
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_5.take(),
-                    SUBPOOL_5_SIZES.take(),
-                    SUBPOOL_5_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_6.take(),
-                    SUBPOOL_6_SIZES.take(),
-                    SUBPOOL_6_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
-            assert!(heapless_pool
-                .grow(
-                    SUBPOOL_3.take(),
-                    SUBPOOL_3_SIZES.take(),
-                    SUBPOOL_3_NUM_ELEMENTS,
-                    true
-                )
-                .is_ok());
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_5.take(),
+                        SUBPOOL_5_SIZES.take(),
+                        SUBPOOL_5_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_6.take(),
+                        SUBPOOL_6_SIZES.take(),
+                        SUBPOOL_6_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
+            assert!(
+                heapless_pool
+                    .grow(
+                        SUBPOOL_3.take(),
+                        SUBPOOL_3_SIZES.take(),
+                        SUBPOOL_3_NUM_ELEMENTS,
+                        true
+                    )
+                    .is_ok()
+            );
            generic_test_spillage_fails_across_multiple_subpools(&mut heapless_pool);
        }
    }
--- a/satrs/src/power.rs
+++ b/satrs/src/power.rs
@@ -190,7 +190,7 @@ mod tests {

    use std::sync::mpsc::{self, TryRecvError};

-    use crate::{queue::GenericSendError, request::GenericMessage, ComponentId};
+    use crate::{ComponentId, queue::GenericSendError, request::GenericMessage};

    use super::*;

--- a/satrs/src/pus/action.rs
+++ b/satrs/src/pus/action.rs
@@ -65,13 +65,13 @@ impl GenericActionReplyPus {
 #[cfg(feature = "alloc")]
 pub mod alloc_mod {
    use crate::{
+        ComponentId,
        action::ActionRequest,
        queue::{GenericReceiveError, GenericSendError},
        request::{
            GenericMessage, MessageReceiverProvider, MessageSenderAndReceiver,
            MessageSenderProvider, MessageSenderStoreProvider, RequestId,
        },
-        ComponentId,
    };

    use super::ActionReplyPus;
@@ -81,10 +81,10 @@ pub mod alloc_mod {
        MessageSenderAndReceiver<ActionReplyPus, ActionRequest, Sender, Receiver, ReplySenderStore>;

    impl<
-            Sender: MessageSenderProvider<ActionReplyPus>,
-            Receiver: MessageReceiverProvider<ActionRequest>,
-            ReplySender: MessageSenderStoreProvider<ActionReplyPus, Sender>,
-        > ActionRequestHandlerInterface<Sender, Receiver, ReplySender>
+        Sender: MessageSenderProvider<ActionReplyPus>,
+        Receiver: MessageReceiverProvider<ActionRequest>,
+        ReplySender: MessageSenderStoreProvider<ActionReplyPus, Sender>,
+    > ActionRequestHandlerInterface<Sender, Receiver, ReplySender>
    {
        pub fn try_recv_action_request(
            &self,
@@ -114,10 +114,10 @@ pub mod alloc_mod {
        >;

    impl<
-            Sender: MessageSenderProvider<ActionRequest>,
-            Receiver: MessageReceiverProvider<ActionReplyPus>,
-            RequestSenderStore: MessageSenderStoreProvider<ActionRequest, Sender>,
-        > ActionRequestorInterface<Sender, Receiver, RequestSenderStore>
+        Sender: MessageSenderProvider<ActionRequest>,
+        Receiver: MessageReceiverProvider<ActionReplyPus>,
+        RequestSenderStore: MessageSenderStoreProvider<ActionRequest, Sender>,
+    > ActionRequestorInterface<Sender, Receiver, RequestSenderStore>
    {
        pub fn try_recv_action_reply(
            &self,
@@ -141,12 +141,12 @@ pub mod std_mod {
    use std::sync::mpsc;

    use crate::{
+        ComponentId,
        pus::{
+            ActivePusRequestStd, ActiveRequest, DefaultActiveRequestMap,
            verification::{self, TcStateToken},
-            ActivePusRequestStd, ActiveRequestProvider, DefaultActiveRequestMap,
        },
        request::{MessageSenderMap, OneMessageSender},
-        ComponentId,
    };

    use super::*;
@@ -157,7 +157,7 @@ pub mod std_mod {
        common: ActivePusRequestStd,
    }

-    impl ActiveRequestProvider for ActivePusActionRequestStd {
+    impl ActiveRequest for ActivePusActionRequestStd {
        delegate::delegate! {
            to self.common {
                fn target_id(&self) -> ComponentId;
--- a/satrs/src/pus/event.rs
+++ b/satrs/src/pus/event.rs
@@ -1,9 +1,9 @@
 use crate::pus::source_buffer_large_enough;
+use spacepackets::ByteConversionError;
+use spacepackets::ecss::EcssEnumeration;
 use spacepackets::ecss::tm::PusTmCreator;
 use spacepackets::ecss::tm::PusTmSecondaryHeader;
-use spacepackets::ecss::EcssEnumeration;
-use spacepackets::ByteConversionError;
-use spacepackets::{SpHeader, MAX_APID};
+use spacepackets::{MAX_APID, SpHeader};

 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -132,31 +132,31 @@ impl EventReportCreator {
 #[cfg(feature = "alloc")]
 mod alloc_mod {
    use super::*;
-    use crate::pus::{EcssTmSender, EcssTmtcError};
    use crate::ComponentId;
+    use crate::pus::{EcssTmSender, EcssTmtcError};
    use alloc::vec;
    use alloc::vec::Vec;
    use core::cell::RefCell;
    use spacepackets::ecss::PusError;

-    pub trait EventTmHookProvider {
+    pub trait EventTmHook {
        fn modify_tm(&self, tm: &mut PusTmCreator);
    }

    #[derive(Default)]
    pub struct DummyEventHook {}

-    impl EventTmHookProvider for DummyEventHook {
+    impl EventTmHook for DummyEventHook {
        fn modify_tm(&self, _tm: &mut PusTmCreator) {}
    }

-    pub struct EventReporter<EventTmHook: EventTmHookProvider = DummyEventHook> {
+    pub struct EventReporter<EventTmHookInstance: EventTmHook = DummyEventHook> {
        id: ComponentId,
        // Use interior mutability pattern here. This is just an intermediate buffer to the PUS event packet
        // generation.
        source_data_buf: RefCell<Vec<u8>>,
        pub report_creator: EventReportCreator,
-        pub tm_hook: EventTmHook,
+        pub tm_hook: EventTmHookInstance,
    }

    impl EventReporter<DummyEventHook> {
@@ -175,13 +175,13 @@ mod alloc_mod {
            })
        }
    }
-    impl<EventTmHook: EventTmHookProvider> EventReporter<EventTmHook> {
+    impl<EventTmHookInstance: EventTmHook> EventReporter<EventTmHookInstance> {
        pub fn new_with_hook(
            id: ComponentId,
            default_apid: u16,
            default_dest_id: u16,
            max_event_id_and_aux_data_size: usize,
-            tm_hook: EventTmHook,
+            tm_hook: EventTmHookInstance,
        ) -> Option<Self> {
            let reporter = EventReportCreator::new(default_apid, default_dest_id)?;
            Some(Self {
@@ -265,13 +265,13 @@ mod alloc_mod {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use crate::ComponentId;
    use crate::events::{EventU32, Severity};
    use crate::pus::test_util::TEST_COMPONENT_ID_0;
    use crate::pus::tests::CommonTmInfo;
    use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant};
-    use crate::ComponentId;
-    use spacepackets::ecss::PusError;
    use spacepackets::ByteConversionError;
+    use spacepackets::ecss::PusError;
    use std::cell::RefCell;
    use std::collections::VecDeque;
    use std::vec::Vec;
--- a/satrs/src/pus/event_man.rs
+++ b/satrs/src/pus/event_man.rs
@@ -6,13 +6,13 @@ use core::hash::Hash;
 #[cfg(feature = "alloc")]
 use hashbrown::HashSet;

-#[cfg(feature = "alloc")]
-pub use crate::pus::event::EventReporter;
-use crate::pus::verification::TcStateToken;
 #[cfg(feature = "alloc")]
 use crate::pus::EcssTmSender;
 use crate::pus::EcssTmtcError;
 #[cfg(feature = "alloc")]
+pub use crate::pus::event::EventReporter;
+use crate::pus::verification::TcStateToken;
+#[cfg(feature = "alloc")]
 pub use alloc_mod::*;
 #[cfg(feature = "heapless")]
 pub use heapless_mod::*;
@@ -46,7 +46,7 @@ pub mod heapless_mod {
    //       regular Event type again.
    #[derive(Default)]
    pub struct HeaplessPusMgmtBackendProvider<const N: usize, Provider: GenericEvent> {
-        disabled: heapless::FnvIndexSet<LargestEventRaw, N>,
+        disabled: heapless::index_set::FnvIndexSet<LargestEventRaw, N>,
        phantom: PhantomData<Provider>,
    }

@@ -102,7 +102,7 @@ pub mod alloc_mod {
    use crate::{
        events::EventU16,
        params::{Params, WritableToBeBytes},
-        pus::event::{DummyEventHook, EventTmHookProvider},
+        pus::event::{DummyEventHook, EventTmHook},
    };

    use super::*;
@@ -151,20 +151,20 @@ pub mod alloc_mod {
    pub struct PusEventTmCreatorWithMap<
        ReportingMap: PusEventReportingMapProvider<Event>,
        Event: GenericEvent,
-        EventTmHook: EventTmHookProvider = DummyEventHook,
+        EventTmHookInstance: EventTmHook = DummyEventHook,
    > {
-        pub reporter: EventReporter<EventTmHook>,
+        pub reporter: EventReporter<EventTmHookInstance>,
        reporting_map: ReportingMap,
        phantom: PhantomData<Event>,
    }

    impl<
-            ReportingMap: PusEventReportingMapProvider<Event>,
-            Event: GenericEvent,
-            EventTmHook: EventTmHookProvider,
-        > PusEventTmCreatorWithMap<ReportingMap, Event, EventTmHook>
+        ReportingMap: PusEventReportingMapProvider<Event>,
+        Event: GenericEvent,
+        EventTmHookInstance: EventTmHook,
+    > PusEventTmCreatorWithMap<ReportingMap, Event, EventTmHookInstance>
    {
-        pub fn new(reporter: EventReporter<EventTmHook>, backend: ReportingMap) -> Self {
+        pub fn new(reporter: EventReporter<EventTmHookInstance>, backend: ReportingMap) -> Self {
            Self {
                reporter,
                reporting_map: backend,
@@ -262,10 +262,10 @@ pub mod alloc_mod {
        }
    }

-    impl<Event: GenericEvent + Copy + PartialEq + Eq + Hash, EventTmHook: EventTmHookProvider>
-        PusEventTmCreatorWithMap<DefaultPusEventReportingMap<Event>, Event, EventTmHook>
+    impl<Event: GenericEvent + Copy + PartialEq + Eq + Hash, EventTmHookInstance: EventTmHook>
+        PusEventTmCreatorWithMap<DefaultPusEventReportingMap<Event>, Event, EventTmHookInstance>
    {
-        pub fn new_with_default_backend(reporter: EventReporter<EventTmHook>) -> Self {
+        pub fn new_with_default_backend(reporter: EventReporter<EventTmHookInstance>) -> Self {
            Self {
                reporter,
                reporting_map: DefaultPusEventReportingMap::default(),
@@ -311,9 +311,9 @@ pub mod alloc_mod {
 mod tests {
    use alloc::string::{String, ToString};
    use alloc::vec;
+    use spacepackets::ecss::PusPacket;
    use spacepackets::ecss::event::Subservice;
    use spacepackets::ecss::tm::PusTmReader;
-    use spacepackets::ecss::PusPacket;

    use super::*;
    use crate::request::UniqueApidTargetId;
@@ -409,7 +409,7 @@ mod tests {
        assert!(res.event_was_enabled);
        assert!(res.params_were_propagated);
        let event_tm = event_rx.try_recv().expect("no event received");
-        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
+        let tm = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
        assert_eq!(tm.service(), 5);
        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
        assert_eq!(tm.user_data().len(), 4 + param_data.len());
@@ -437,7 +437,7 @@ mod tests {
        assert!(res.event_was_enabled);
        assert!(res.params_were_propagated);
        let event_tm = event_rx.try_recv().expect("no event received");
-        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
+        let tm = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
        assert_eq!(tm.service(), 5);
        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
        assert_eq!(tm.user_data().len(), 4 + param_data.len());
--- a/satrs/src/pus/event_srv.rs
+++ b/satrs/src/pus/event_srv.rs
@@ -3,20 +3,20 @@ use crate::pus::event_man::{EventRequest, EventRequestWithToken};
 use crate::pus::verification::TcStateToken;
 use crate::pus::{DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError};
 use crate::queue::GenericSendError;
-use spacepackets::ecss::event::Subservice;
 use spacepackets::ecss::PusPacket;
+use spacepackets::ecss::event::Subservice;
 use std::sync::mpsc::Sender;

 use super::verification::VerificationReportingProvider;
 use super::{
-    EcssTcInMemConversionProvider, EcssTcReceiver, EcssTmSender, GenericConversionError,
+    CacheAndReadRawEcssTc, EcssTcReceiver, EcssTmSender, GenericConversionError,
    GenericRoutingError, HandlingStatus, PusServiceHelper,
 };

 pub struct PusEventServiceHandler<
    TcReceiver: EcssTcReceiver,
    TmSender: EcssTmSender,
-    TcInMemConverter: EcssTcInMemConversionProvider,
+    TcInMemConverter: CacheAndReadRawEcssTc,
    VerificationReporter: VerificationReportingProvider,
 > {
    pub service_helper:
@@ -25,11 +25,11 @@ pub struct PusEventServiceHandler<
 }

 impl<
-        TcReceiver: EcssTcReceiver,
-        TmSender: EcssTmSender,
-        TcInMemConverter: EcssTcInMemConversionProvider,
-        VerificationReporter: VerificationReportingProvider,
-    > PusEventServiceHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
+    TcReceiver: EcssTcReceiver,
+    TmSender: EcssTmSender,
+    TcInMemConverter: CacheAndReadRawEcssTc,
+    VerificationReporter: VerificationReportingProvider,
+> PusEventServiceHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
 {
    pub fn new(
        service_helper: PusServiceHelper<
@@ -122,7 +122,7 @@ impl<
            | Subservice::TmHighSeverityReport => {
                return Err(PusPacketHandlingError::RequestConversion(
                    GenericConversionError::WrongService(tc.subservice()),
-                ))
+                ));
            }
            Subservice::TcEnableEventGeneration => {
                handle_enable_disable_request(true)?;
@@ -146,14 +146,14 @@ impl<
 mod tests {
    use delegate::delegate;
    use spacepackets::ecss::event::Subservice;
-    use spacepackets::time::{cds, TimeWriter};
+    use spacepackets::time::{TimeWriter, cds};
    use spacepackets::util::UnsignedEnum;
    use spacepackets::{
+        SpHeader,
        ecss::{
            tc::{PusTcCreator, PusTcSecondaryHeader},
            tm::PusTmReader,
        },
-        SpHeader,
    };
    use std::sync::mpsc::{self, Sender};

@@ -167,10 +167,10 @@ mod tests {
    use crate::{
        events::EventU32,
        pus::{
+            DirectPusPacketHandlerResult, EcssTcInSharedPoolCacher, PusPacketHandlingError,
            event_man::EventRequestWithToken,
            tests::PusServiceHandlerWithSharedStoreCommon,
            verification::{TcStateAccepted, VerificationToken},
-            DirectPusPacketHandlerResult, EcssTcInSharedPoolConverter, PusPacketHandlingError,
        },
    };

@@ -183,7 +183,7 @@ mod tests {
        handler: PusEventServiceHandler<
            MpscTcReceiver,
            PacketSenderWithSharedPool,
-            EcssTcInSharedPoolConverter,
+            EcssTcInSharedPoolCacher,
            VerificationReporter,
        >,
    }
@@ -199,8 +199,12 @@ mod tests {
    }

    impl PusTestHarness for Pus5HandlerWithStoreTester {
-        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let init_token = self.handler.service_helper.verif_reporter_mut().add_tc(tc);
+        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+            let init_token = self
+                .handler
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
            self.handler
                .service_helper
                .verif_reporter()
@@ -245,7 +249,7 @@ mod tests {
            .write_to_be_bytes(&mut app_data)
            .expect("writing test event failed");
        let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
        test_harness.handle_one_tc().unwrap();
@@ -306,7 +310,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(5, 200);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_ok());
@@ -326,7 +330,7 @@ mod tests {
        let sec_header =
            PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8);
        let ping_tc = PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_err());
--- a/satrs/src/pus/mod.rs
+++ b/satrs/src/pus/mod.rs
@@ -2,6 +2,7 @@
 //!
 //! This module contains structures to make working with the PUS C standard easier.
 //! The satrs-example application contains various usage examples of these components.
+use crate::ComponentId;
 use crate::pool::{PoolAddr, PoolError};
 use crate::pus::verification::{TcStateAccepted, TcStateToken, VerificationToken};
 use crate::queue::{GenericReceiveError, GenericSendError};
@@ -9,19 +10,18 @@ use crate::request::{GenericMessage, MessageMetadata, RequestId};
 #[cfg(feature = "alloc")]
 use crate::tmtc::PacketAsVec;
 use crate::tmtc::PacketInPool;
-use crate::ComponentId;
 use core::fmt::{Display, Formatter};
 use core::time::Duration;
 #[cfg(feature = "alloc")]
-use downcast_rs::{impl_downcast, Downcast};
+use downcast_rs::{Downcast, impl_downcast};
 #[cfg(feature = "alloc")]
 use dyn_clone::DynClone;
 #[cfg(feature = "std")]
 use std::error::Error;

+use spacepackets::ecss::PusError;
 use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
 use spacepackets::ecss::tm::PusTmCreator;
-use spacepackets::ecss::PusError;
 use spacepackets::{ByteConversionError, SpHeader};

 pub mod action;
@@ -296,7 +296,7 @@ pub trait PacketSenderPusTc: Send {
    ) -> Result<(), Self::Error>;
 }

-pub trait ActiveRequestMapProvider<V>: Sized {
+pub trait ActiveRequestStore<V>: Sized {
    fn insert(&mut self, request_id: &RequestId, request_info: V);
    fn get(&self, request_id: RequestId) -> Option<&V>;
    fn get_mut(&mut self, request_id: RequestId) -> Option<&mut V>;
@@ -309,7 +309,7 @@ pub trait ActiveRequestMapProvider<V>: Sized {
    fn for_each_mut<F: FnMut(&RequestId, &mut V)>(&mut self, f: F);
 }

-pub trait ActiveRequestProvider {
+pub trait ActiveRequest {
    fn target_id(&self) -> ComponentId;
    fn token(&self) -> TcStateToken;
    fn set_token(&mut self, token: TcStateToken);
@@ -330,7 +330,7 @@ pub trait PusRequestRouter<Request> {
    ) -> Result<(), Self::Error>;
 }

-pub trait PusReplyHandler<ActiveRequestInfo: ActiveRequestProvider, ReplyType> {
+pub trait PusReplyHandler<ActiveRequestInfo: ActiveRequest, ReplyType> {
    type Error;

    /// This function handles a reply for a given PUS request and returns whether that request
@@ -459,7 +459,7 @@ pub mod alloc_mod {
    ///
    /// A [VerificationReportingProvider] instance is passed to the user to also allow handling
    /// of the verification process as part of the PUS standard requirements.
-    pub trait PusTcToRequestConverter<ActiveRequestInfo: ActiveRequestProvider, Request> {
+    pub trait PusTcToRequestConverter<ActiveRequestInfo: ActiveRequest, Request> {
        type Error;
        fn convert(
            &mut self,
@@ -480,7 +480,7 @@ pub mod alloc_mod {
        }
    }

-    impl<V> ActiveRequestMapProvider<V> for DefaultActiveRequestMap<V> {
+    impl<V> ActiveRequestStore<V> for DefaultActiveRequestMap<V> {
        fn insert(&mut self, request_id: &RequestId, request: V) {
            self.0.insert(*request_id, request);
        }
@@ -659,18 +659,18 @@ pub mod alloc_mod {
 #[cfg(feature = "std")]
 pub mod std_mod {
    use super::*;
+    use crate::ComponentId;
    use crate::pool::{
        PoolAddr, PoolError, PoolProvider, PoolProviderWithGuards, SharedStaticMemoryPool,
    };
    use crate::pus::verification::{TcStateAccepted, VerificationToken};
    use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
-    use crate::ComponentId;
    use alloc::vec::Vec;
    use core::time::Duration;
-    use spacepackets::ecss::tc::PusTcReader;
-    use spacepackets::ecss::WritablePusPacket;
-    use spacepackets::time::StdTimestampError;
    use spacepackets::ByteConversionError;
+    use spacepackets::ecss::WritablePusPacket;
+    use spacepackets::ecss::tc::PusTcReader;
+    use spacepackets::time::StdTimestampError;
    use std::string::String;
    use std::sync::mpsc;
    use std::sync::mpsc::TryRecvError;
@@ -680,7 +680,7 @@ pub mod std_mod {
    pub use cb_mod::*;

    use super::verification::{TcStateToken, VerificationReportingProvider};
-    use super::{AcceptedEcssTcAndToken, ActiveRequestProvider, TcInMemory};
+    use super::{AcceptedEcssTcAndToken, ActiveRequest, TcInMemory};
    use crate::tmtc::PacketInPool;

    impl From<mpsc::SendError<PoolAddr>> for EcssTmtcError {
@@ -845,7 +845,7 @@ pub mod std_mod {
        }
    }

-    impl ActiveRequestProvider for ActivePusRequestStd {
+    impl ActiveRequest for ActivePusRequestStd {
        fn target_id(&self) -> ComponentId {
            self.target_id
        }
@@ -947,7 +947,9 @@ pub mod std_mod {
        }
    }

-    pub trait EcssTcInMemConversionProvider {
+    /// This trait provides an abstraction for caching a raw ECSS telecommand and then
+    /// providing the [PusTcReader] abstraction to read the cache raw telecommand.
+    pub trait CacheAndReadRawEcssTc {
        fn cache(&mut self, possible_packet: &TcInMemory) -> Result<(), PusTcFromMemError>;

        fn tc_slice_raw(&self) -> &[u8];
@@ -959,15 +961,11 @@ pub mod std_mod {
            possible_packet: &TcInMemory,
        ) -> Result<PusTcReader<'_>, PusTcFromMemError> {
            self.cache(possible_packet)?;
-            Ok(PusTcReader::new(self.tc_slice_raw())
-                .map_err(EcssTmtcError::Pus)?
-                .0)
+            Ok(PusTcReader::new(self.tc_slice_raw()).map_err(EcssTmtcError::Pus)?)
        }

        fn convert(&self) -> Result<PusTcReader<'_>, PusTcFromMemError> {
-            Ok(PusTcReader::new(self.tc_slice_raw())
-                .map_err(EcssTmtcError::Pus)?
-                .0)
+            Ok(PusTcReader::new(self.tc_slice_raw()).map_err(EcssTmtcError::Pus)?)
        }
    }

@@ -975,12 +973,12 @@ pub mod std_mod {
    /// Please note that this structure is not able to convert TCs which are stored inside a
    /// [SharedStaticMemoryPool].
    #[derive(Default, Clone)]
-    pub struct EcssTcInVecConverter {
+    pub struct EcssTcVecCacher {
        sender_id: Option<ComponentId>,
        pub pus_tc_raw: Option<Vec<u8>>,
    }

-    impl EcssTcInMemConversionProvider for EcssTcInVecConverter {
+    impl CacheAndReadRawEcssTc for EcssTcVecCacher {
        fn cache(&mut self, tc_in_memory: &TcInMemory) -> Result<(), PusTcFromMemError> {
            self.pus_tc_raw = None;
            match tc_in_memory {
@@ -1012,13 +1010,13 @@ pub mod std_mod {
    /// packets should be avoided. Please note that this structure is not able to convert TCs which
    /// are stored as a `Vec<u8>`.
    #[derive(Clone)]
-    pub struct EcssTcInSharedPoolConverter {
+    pub struct EcssTcInSharedPoolCacher {
        sender_id: Option<ComponentId>,
        shared_tc_pool: SharedStaticMemoryPool,
        pus_buf: Vec<u8>,
    }

-    impl EcssTcInSharedPoolConverter {
+    impl EcssTcInSharedPoolCacher {
        pub fn new(shared_tc_store: SharedStaticMemoryPool, max_expected_tc_size: usize) -> Self {
            Self {
                sender_id: None,
@@ -1049,7 +1047,7 @@ pub mod std_mod {
        }
    }

-    impl EcssTcInMemConversionProvider for EcssTcInSharedPoolConverter {
+    impl CacheAndReadRawEcssTc for EcssTcInSharedPoolCacher {
        fn cache(&mut self, tc_in_memory: &TcInMemory) -> Result<(), PusTcFromMemError> {
            match tc_in_memory {
                super::TcInMemory::Pool(packet_in_pool) => {
@@ -1074,38 +1072,38 @@ pub mod std_mod {

    // TODO: alloc feature flag?
    #[derive(Clone)]
-    pub enum EcssTcInMemConverter {
-        Static(EcssTcInSharedPoolConverter),
-        Heap(EcssTcInVecConverter),
+    pub enum EcssTcCacher {
+        Static(EcssTcInSharedPoolCacher),
+        Heap(EcssTcVecCacher),
    }

-    impl EcssTcInMemConverter {
-        pub fn new_static(static_store_converter: EcssTcInSharedPoolConverter) -> Self {
-            EcssTcInMemConverter::Static(static_store_converter)
+    impl EcssTcCacher {
+        pub fn new_static(static_store_converter: EcssTcInSharedPoolCacher) -> Self {
+            Self::Static(static_store_converter)
        }

-        pub fn new_heap(heap_converter: EcssTcInVecConverter) -> Self {
-            EcssTcInMemConverter::Heap(heap_converter)
+        pub fn new_heap(heap_converter: EcssTcVecCacher) -> Self {
+            Self::Heap(heap_converter)
        }
    }

-    impl EcssTcInMemConversionProvider for EcssTcInMemConverter {
+    impl CacheAndReadRawEcssTc for EcssTcCacher {
        fn cache(&mut self, tc_in_memory: &TcInMemory) -> Result<(), PusTcFromMemError> {
            match self {
-                EcssTcInMemConverter::Static(converter) => converter.cache(tc_in_memory),
-                EcssTcInMemConverter::Heap(converter) => converter.cache(tc_in_memory),
+                Self::Static(converter) => converter.cache(tc_in_memory),
+                Self::Heap(converter) => converter.cache(tc_in_memory),
            }
        }
        fn tc_slice_raw(&self) -> &[u8] {
            match self {
-                EcssTcInMemConverter::Static(converter) => converter.tc_slice_raw(),
-                EcssTcInMemConverter::Heap(converter) => converter.tc_slice_raw(),
+                Self::Static(converter) => converter.tc_slice_raw(),
+                Self::Heap(converter) => converter.tc_slice_raw(),
            }
        }
        fn sender_id(&self) -> Option<ComponentId> {
            match self {
-                EcssTcInMemConverter::Static(converter) => converter.sender_id(),
-                EcssTcInMemConverter::Heap(converter) => converter.sender_id(),
+                Self::Static(converter) => converter.sender_id(),
+                Self::Heap(converter) => converter.sender_id(),
            }
        }
    }
@@ -1133,7 +1131,7 @@ pub mod std_mod {
    pub struct PusServiceHelper<
        TcReceiver: EcssTcReceiver,
        TmSender: EcssTmSender,
-        TcInMemConverter: EcssTcInMemConversionProvider,
+        TcInMemConverter: CacheAndReadRawEcssTc,
        VerificationReporter: VerificationReportingProvider,
    > {
        pub common: PusServiceBase<TcReceiver, TmSender, VerificationReporter>,
@@ -1141,11 +1139,11 @@ pub mod std_mod {
    }

    impl<
-            TcReceiver: EcssTcReceiver,
-            TmSender: EcssTmSender,
-            TcInMemConverter: EcssTcInMemConversionProvider,
-            VerificationReporter: VerificationReportingProvider,
-        > PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
+        TcReceiver: EcssTcReceiver,
+        TmSender: EcssTmSender,
+        TcInMemConverter: CacheAndReadRawEcssTc,
+        VerificationReporter: VerificationReportingProvider,
+    > PusServiceHelper<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
    {
        pub fn new(
            id: ComponentId,
@@ -1265,8 +1263,8 @@ pub mod test_util {
    use crate::request::UniqueApidTargetId;

    use super::{
-        verification::{self, TcStateAccepted, VerificationToken},
        DirectPusPacketHandlerResult, PusPacketHandlingError,
+        verification::{self, TcStateAccepted, VerificationToken},
    };

    pub const TEST_APID: u16 = 0x101;
@@ -1279,7 +1277,7 @@ pub mod test_util {
        UniqueApidTargetId::new(TEST_APID, TEST_UNIQUE_ID_1);

    pub trait PusTestHarness {
-        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted>;
+        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted>;
        fn send_tc(&self, token: &VerificationToken<TcStateAccepted>, tc: &PusTcCreator);
        fn read_next_tm(&mut self) -> PusTmReader<'_>;
        fn check_no_tm_available(&self) -> bool;
@@ -1292,7 +1290,7 @@ pub mod test_util {

    pub trait SimplePusPacketHandler {
        fn handle_one_tc(&mut self)
-            -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError>;
+        -> Result<DirectPusPacketHandlerResult, PusPacketHandlingError>;
    }
 }

@@ -1300,25 +1298,26 @@ pub mod test_util {
 pub mod tests {
    use core::cell::RefCell;
    use std::sync::mpsc::TryRecvError;
-    use std::sync::{mpsc, RwLock};
+    use std::sync::{RwLock, mpsc};

    use alloc::collections::VecDeque;
    use alloc::vec::Vec;
    use satrs_shared::res_code::ResultU16;
+    use spacepackets::CcsdsPacket;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
    use spacepackets::ecss::tm::{GenericPusTmSecondaryHeader, PusTmCreator, PusTmReader};
    use spacepackets::ecss::{PusPacket, WritablePusPacket};
-    use spacepackets::CcsdsPacket;
    use test_util::{TEST_APID, TEST_COMPONENT_ID_0};

+    use crate::ComponentId;
    use crate::pool::{PoolProvider, SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
    use crate::pus::verification::{RequestId, VerificationReporter};
    use crate::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool, SharedPacketPool};
-    use crate::ComponentId;

    use super::verification::test_util::TestVerificationReporter;
    use super::verification::{
-        TcStateAccepted, VerificationReporterCfg, VerificationReportingProvider, VerificationToken,
+        TcStateAccepted, VerificationReporterConfig, VerificationReportingProvider,
+        VerificationToken,
    };
    use super::*;

@@ -1386,7 +1385,7 @@ pub mod tests {
    pub type PusServiceHelperStatic = PusServiceHelper<
        MpscTcReceiver,
        PacketSenderWithSharedPool,
-        EcssTcInSharedPoolConverter,
+        EcssTcInSharedPoolCacher,
        VerificationReporter,
    >;

@@ -1408,12 +1407,12 @@ pub mod tests {
            let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::sync_channel(10);
            let (tm_tx, tm_rx) = mpsc::sync_channel(10);

-            let verif_cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
            let verification_handler =
                VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &verif_cfg);
            let test_srv_tm_sender =
                PacketSenderWithSharedPool::new(tm_tx, shared_tm_pool_wrapper.clone());
-            let in_store_converter = EcssTcInSharedPoolConverter::new(shared_tc_pool.clone(), 2048);
+            let in_store_converter = EcssTcInSharedPoolCacher::new(shared_tc_pool.clone(), 2048);
            (
                Self {
                    pus_buf: RefCell::new([0; 2048]),
@@ -1459,7 +1458,7 @@ pub mod tests {
            let tm_pool = self.tm_pool.0.read().unwrap();
            let tm_raw = tm_pool.read_as_vec(&tm_in_pool.store_addr).unwrap();
            self.tm_buf[0..tm_raw.len()].copy_from_slice(&tm_raw);
-            PusTmReader::new(&self.tm_buf, 7).unwrap().0
+            PusTmReader::new(&self.tm_buf, 7).unwrap()
        }

        pub fn check_no_tm_available(&self) -> bool {
@@ -1476,7 +1475,7 @@ pub mod tests {
            let tm_in_pool = next_msg.unwrap();
            let tm_pool = self.tm_pool.0.read().unwrap();
            let tm_raw = tm_pool.read_as_vec(&tm_in_pool.store_addr).unwrap();
-            let tm = PusTmReader::new(&tm_raw, 7).unwrap().0;
+            let tm = PusTmReader::new(&tm_raw, 7).unwrap();
            assert_eq!(PusPacket::service(&tm), 1);
            assert_eq!(PusPacket::subservice(&tm), subservice);
            assert_eq!(tm.apid(), TEST_APID);
@@ -1491,12 +1490,8 @@ pub mod tests {
        tc_sender: mpsc::Sender<EcssTcAndToken>,
        tm_receiver: mpsc::Receiver<PacketAsVec>,
    }
-    pub type PusServiceHelperDynamic = PusServiceHelper<
-        MpscTcReceiver,
-        MpscTmAsVecSender,
-        EcssTcInVecConverter,
-        VerificationReporter,
-    >;
+    pub type PusServiceHelperDynamic =
+        PusServiceHelper<MpscTcReceiver, MpscTmAsVecSender, EcssTcVecCacher, VerificationReporter>;

    impl PusServiceHandlerWithVecCommon {
        pub fn new_with_standard_verif_reporter(
@@ -1505,10 +1500,10 @@ pub mod tests {
            let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
            let (tm_tx, tm_rx) = mpsc::channel();

-            let verif_cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+            let verif_cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
            let verification_handler =
                VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &verif_cfg);
-            let in_store_converter = EcssTcInVecConverter::default();
+            let in_store_converter = EcssTcVecCacher::default();
            (
                Self {
                    current_tm: None,
@@ -1534,14 +1529,14 @@ pub mod tests {
            PusServiceHelper<
                MpscTcReceiver,
                MpscTmAsVecSender,
-                EcssTcInVecConverter,
+                EcssTcVecCacher,
                TestVerificationReporter,
            >,
        ) {
            let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
            let (tm_tx, tm_rx) = mpsc::channel();

-            let in_store_converter = EcssTcInVecConverter::default();
+            let in_store_converter = EcssTcVecCacher::default();
            let verification_handler = TestVerificationReporter::new(id);
            (
                Self {
@@ -1584,9 +1579,7 @@ pub mod tests {
            let next_msg = self.tm_receiver.try_recv();
            assert!(next_msg.is_ok());
            self.current_tm = Some(next_msg.unwrap().packet);
-            PusTmReader::new(self.current_tm.as_ref().unwrap(), 7)
-                .unwrap()
-                .0
+            PusTmReader::new(self.current_tm.as_ref().unwrap(), 7).unwrap()
        }

        pub fn check_no_tm_available(&self) -> bool {
@@ -1601,7 +1594,7 @@ pub mod tests {
            let next_msg = self.tm_receiver.try_recv();
            assert!(next_msg.is_ok());
            let next_msg = next_msg.unwrap();
-            let tm = PusTmReader::new(next_msg.packet.as_slice(), 7).unwrap().0;
+            let tm = PusTmReader::new(next_msg.packet.as_slice(), 7).unwrap();
            assert_eq!(PusPacket::service(&tm), 1);
            assert_eq!(PusPacket::subservice(&tm), subservice);
            assert_eq!(tm.apid(), TEST_APID);
--- a/satrs/src/pus/scheduler.rs
+++ b/satrs/src/pus/scheduler.rs
@@ -292,10 +292,10 @@ pub trait PusSchedulerProvider {
        pool: &mut (impl PoolProvider + ?Sized),
    ) -> Result<TcInfo, ScheduleError> {
        let check_tc = PusTcReader::new(tc)?;
-        if PusPacket::service(&check_tc.0) == 11 && PusPacket::subservice(&check_tc.0) == 4 {
+        if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
            return Err(ScheduleError::NestedScheduledTc);
        }
-        let req_id = RequestId::from_tc(&check_tc.0);
+        let req_id = RequestId::from_tc(&check_tc);

        match pool.add(tc) {
            Ok(addr) => {
@@ -340,8 +340,8 @@ pub fn generate_insert_telecommand_app_data(
 pub mod alloc_mod {
    use alloc::{
        collections::{
-            btree_map::{Entry, Range},
            BTreeMap,
+            btree_map::{Entry, Range},
        },
        vec::Vec,
    };
@@ -411,10 +411,10 @@ pub mod alloc_mod {
        ///
        /// * `init_current_time` - The time to initialize the scheduler with.
        /// * `time_margin` - This time margin is used when inserting new telecommands into the
-        ///      schedule. If the release time of a new telecommand is earlier than the time margin
-        ///      added to the current time, it will not be inserted into the schedule.
+        ///   schedule. If the release time of a new telecommand is earlier than the time margin
+        ///   added to the current time, it will not be inserted into the schedule.
        /// * `tc_buf_size` - Buffer for temporary storage of telecommand packets. This buffer
-        ///      should be large enough to accomodate the largest expected TC packets.
+        ///   should be large enough to accomodate the largest expected TC packets.
        pub fn new(init_current_time: UnixTime, time_margin: Duration) -> Self {
            PusScheduler {
                tc_map: Default::default(),
@@ -480,10 +480,10 @@ pub mod alloc_mod {
            pool: &mut (impl PoolProvider + ?Sized),
        ) -> Result<TcInfo, ScheduleError> {
            let check_tc = PusTcReader::new(tc)?;
-            if PusPacket::service(&check_tc.0) == 11 && PusPacket::subservice(&check_tc.0) == 4 {
+            if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
                return Err(ScheduleError::NestedScheduledTc);
            }
-            let req_id = RequestId::from_tc(&check_tc.0);
+            let req_id = RequestId::from_tc(&check_tc);

            match pool.add(tc) {
                Ok(addr) => {
@@ -683,10 +683,10 @@ pub mod alloc_mod {
        /// # Arguments
        ///
        /// * `releaser` - Closure where the first argument is whether the scheduler is enabled and
-        ///     the second argument is the telecommand information also containing the store
-        ///     address. This closure should return whether the command should be deleted. Please
-        ///     note that returning false might lead to memory leaks if the TC is not cleared from
-        ///     the store in some other way.
+        ///   the second argument is the telecommand information also containing the store
+        ///   address. This closure should return whether the command should be deleted. Please
+        ///   note that returning false might lead to memory leaks if the TC is not cleared from
+        ///   the store in some other way.
        /// * `tc_store` - The holding store of the telecommands.
        /// * `tc_buf` - Buffer to hold each telecommand being released.
        pub fn release_telecommands_with_buffer<R: FnMut(bool, &TcInfo, &[u8]) -> bool>(
@@ -855,9 +855,9 @@ mod tests {
        PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig,
    };
    use alloc::collections::btree_map::Range;
-    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::WritablePusPacket;
-    use spacepackets::time::{cds, TimeWriter, UnixTime};
+    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
+    use spacepackets::time::{TimeWriter, UnixTime, cds};
    use spacepackets::{PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader};
    use std::time::Duration;
    use std::vec::Vec;
@@ -878,22 +878,22 @@ mod tests {
        )
    }

-    fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator {
+    fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
        PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], true)
    }

-    fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator {
+    fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
        PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], true)
    }

-    fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator {
+    fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let (sph, len_app_data) = pus_tc_base(timestamp, buf);
        PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], true)
    }

-    fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator {
+    fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
        let cds_time =
            cds::CdsTime::from_unix_time_with_u16_days(&timestamp, cds::SubmillisPrecision::Absent)
                .unwrap();
@@ -1313,7 +1313,7 @@ mod tests {
        let mut read_buf: [u8; 64] = [0; 64];
        pool.read(&tc_info_0.addr(), &mut read_buf).unwrap();
        let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));

        assert_eq!(scheduler.num_scheduled_telecommands(), 1);

@@ -1335,8 +1335,8 @@ mod tests {

        let read_len = pool.read(&addr_vec[0], &mut read_buf).unwrap();
        let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
-        assert_eq!(read_len, check_tc.1);
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.total_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
    }

    #[test]
@@ -1362,8 +1362,8 @@ mod tests {

        let read_len = pool.read(&info.addr, &mut buf).unwrap();
        let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data");
-        assert_eq!(read_len, check_tc.1);
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.total_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));

        assert_eq!(scheduler.num_scheduled_telecommands(), 1);

@@ -1387,8 +1387,8 @@ mod tests {

        let read_len = pool.read(&addr_vec[0], &mut buf).unwrap();
        let check_tc = PusTcReader::new(&buf).expect("incorrect PUS tc raw data");
-        assert_eq!(read_len, check_tc.1);
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(read_len, check_tc.total_len());
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
    }

    #[test]
@@ -2031,7 +2031,7 @@ mod tests {
        assert_eq!(n, 1);
        let time_reader = cds::CdsTime::from_bytes_with_u16_days(&buf[2..2 + 7]).unwrap();
        assert_eq!(time_reader, time_writer);
-        let pus_tc_reader = PusTcReader::new(&buf[9..]).unwrap().0;
+        let pus_tc_reader = PusTcReader::new(&buf[9..]).unwrap();
        assert_eq!(pus_tc_reader, ping_tc);
    }

--- a/satrs/src/pus/scheduler_srv.rs
+++ b/satrs/src/pus/scheduler_srv.rs
@@ -1,15 +1,15 @@
 use super::scheduler::PusSchedulerProvider;
 use super::verification::{VerificationReporter, VerificationReportingProvider};
 use super::{
-    DirectPusPacketHandlerResult, EcssTcInMemConversionProvider, EcssTcInSharedPoolConverter,
-    EcssTcInVecConverter, EcssTcReceiver, EcssTmSender, HandlingStatus, MpscTcReceiver,
-    PartialPusHandlingError, PusServiceHelper,
+    CacheAndReadRawEcssTc, DirectPusPacketHandlerResult, EcssTcInSharedPoolCacher, EcssTcReceiver,
+    EcssTcVecCacher, EcssTmSender, HandlingStatus, MpscTcReceiver, PartialPusHandlingError,
+    PusServiceHelper,
 };
 use crate::pool::PoolProvider;
 use crate::pus::PusPacketHandlingError;
 use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
 use alloc::string::ToString;
-use spacepackets::ecss::{scheduling, PusPacket};
+use spacepackets::ecss::{PusPacket, scheduling};
 use spacepackets::time::cds::CdsTime;
 use std::sync::mpsc;

@@ -24,7 +24,7 @@ use std::sync::mpsc;
 pub struct PusSchedServiceHandler<
    TcReceiver: EcssTcReceiver,
    TmSender: EcssTmSender,
-    TcInMemConverter: EcssTcInMemConversionProvider,
+    TcInMemConverter: CacheAndReadRawEcssTc,
    VerificationReporter: VerificationReportingProvider,
    PusScheduler: PusSchedulerProvider,
 > {
@@ -34,13 +34,12 @@ pub struct PusSchedServiceHandler<
 }

 impl<
-        TcReceiver: EcssTcReceiver,
-        TmSender: EcssTmSender,
-        TcInMemConverter: EcssTcInMemConversionProvider,
-        VerificationReporter: VerificationReportingProvider,
-        Scheduler: PusSchedulerProvider,
-    >
-    PusSchedServiceHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter, Scheduler>
+    TcReceiver: EcssTcReceiver,
+    TmSender: EcssTmSender,
+    TcInMemConverter: CacheAndReadRawEcssTc,
+    VerificationReporter: VerificationReportingProvider,
+    Scheduler: PusSchedulerProvider,
+> PusSchedServiceHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter, Scheduler>
 {
    pub fn new(
        service_helper: PusServiceHelper<
@@ -102,11 +101,12 @@ impl<
                    }
                };
                self.scheduler.enable();
-
-                if self.scheduler.is_enabled() && opt_started_token.is_some() {
+                if self.scheduler.is_enabled()
+                    && let Some(started_token) = opt_started_token
+                {
                    if let Err(e) = self.service_helper.verif_reporter().completion_success(
                        &self.service_helper.common.tm_sender,
-                        opt_started_token.unwrap(),
+                        started_token,
                        time_stamp,
                    ) {
                        error_callback(&PartialPusHandlingError::Verification(e));
@@ -131,10 +131,12 @@ impl<
                };

                self.scheduler.disable();
-                if !self.scheduler.is_enabled() && opt_started_token.is_some() {
+                if !self.scheduler.is_enabled()
+                    && let Some(started_token) = opt_started_token
+                {
                    if let Err(e) = self.service_helper.verif_reporter().completion_success(
                        &self.service_helper.common.tm_sender,
-                        opt_started_token.unwrap(),
+                        started_token,
                        time_stamp,
                    ) {
                        error_callback(&PartialPusHandlingError::Verification(e));
@@ -211,7 +213,7 @@ impl<
 pub type PusService11SchedHandlerDynWithMpsc<PusScheduler> = PusSchedServiceHandler<
    MpscTcReceiver,
    mpsc::Sender<PacketAsVec>,
-    EcssTcInVecConverter,
+    EcssTcVecCacher,
    VerificationReporter,
    PusScheduler,
 >;
@@ -220,7 +222,7 @@ pub type PusService11SchedHandlerDynWithMpsc<PusScheduler> = PusSchedServiceHand
 pub type PusService11SchedHandlerDynWithBoundedMpsc<PusScheduler> = PusSchedServiceHandler<
    MpscTcReceiver,
    mpsc::SyncSender<PacketAsVec>,
-    EcssTcInVecConverter,
+    EcssTcVecCacher,
    VerificationReporter,
    PusScheduler,
 >;
@@ -229,7 +231,7 @@ pub type PusService11SchedHandlerDynWithBoundedMpsc<PusScheduler> = PusSchedServ
 pub type PusService11SchedHandlerStaticWithMpsc<PusScheduler> = PusSchedServiceHandler<
    MpscTcReceiver,
    PacketSenderWithSharedPool,
-    EcssTcInSharedPoolConverter,
+    EcssTcInSharedPoolCacher,
    VerificationReporter,
    PusScheduler,
 >;
@@ -238,7 +240,7 @@ pub type PusService11SchedHandlerStaticWithMpsc<PusScheduler> = PusSchedServiceH
 pub type PusService11SchedHandlerStaticWithBoundedMpsc<PusScheduler> = PusSchedServiceHandler<
    MpscTcReceiver,
    PacketSenderWithSharedPool,
-    EcssTcInSharedPoolConverter,
+    EcssTcInSharedPoolCacher,
    VerificationReporter,
    PusScheduler,
 >;
@@ -249,21 +251,21 @@ mod tests {
    use crate::pus::test_util::{PusTestHarness, TEST_APID};
    use crate::pus::verification::{VerificationReporter, VerificationReportingProvider};

+    use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError};
    use crate::pus::{
+        EcssTcInSharedPoolCacher,
        scheduler::{self, PusSchedulerProvider, TcInfo},
        tests::PusServiceHandlerWithSharedStoreCommon,
        verification::{RequestId, TcStateAccepted, VerificationToken},
-        EcssTcInSharedPoolConverter,
    };
-    use crate::pus::{DirectPusPacketHandlerResult, MpscTcReceiver, PusPacketHandlingError};
    use crate::tmtc::PacketSenderWithSharedPool;
    use alloc::collections::VecDeque;
    use delegate::delegate;
+    use spacepackets::SpHeader;
+    use spacepackets::ecss::WritablePusPacket;
    use spacepackets::ecss::scheduling::Subservice;
    use spacepackets::ecss::tc::PusTcSecondaryHeader;
-    use spacepackets::ecss::WritablePusPacket;
    use spacepackets::time::TimeWriter;
-    use spacepackets::SpHeader;
    use spacepackets::{
        ecss::{tc::PusTcCreator, tm::PusTmReader},
        time::cds,
@@ -276,7 +278,7 @@ mod tests {
        handler: PusSchedServiceHandler<
            MpscTcReceiver,
            PacketSenderWithSharedPool,
-            EcssTcInSharedPoolConverter,
+            EcssTcInSharedPoolCacher,
            VerificationReporter,
            TestScheduler,
        >,
@@ -309,8 +311,12 @@ mod tests {
    }

    impl PusTestHarness for Pus11HandlerWithStoreTester {
-        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let init_token = self.handler.service_helper.verif_reporter_mut().add_tc(tc);
+        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+            let init_token = self
+                .handler
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
            self.handler
                .service_helper
                .verif_reporter()
@@ -383,7 +389,7 @@ mod tests {
        let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, 0, 0);
        let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8);
        let enable_scheduling = PusTcCreator::new(reply_header, tc_header, &[0; 7], true);
-        let token = test_harness.init_verification(&enable_scheduling);
+        let token = test_harness.start_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);

        let request_id = token.request_id();
@@ -445,7 +451,7 @@ mod tests {
            &sched_app_data[..written_len],
            true,
        );
-        let token = test_harness.init_verification(&enable_scheduling);
+        let token = test_harness.start_verification(&enable_scheduling);
        test_harness.send_tc(&token, &enable_scheduling);

        let request_id = token.request_id();
--- a/satrs/src/pus/test.rs
+++ b/satrs/src/pus/test.rs
@@ -2,16 +2,15 @@ use crate::pus::{
    DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant,
 };
 use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
-use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::ecss::PusPacket;
 use spacepackets::SpHeader;
+use spacepackets::ecss::PusPacket;
+use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use std::sync::mpsc;

 use super::verification::{VerificationReporter, VerificationReportingProvider};
 use super::{
-    EcssTcInMemConversionProvider, EcssTcInSharedPoolConverter, EcssTcInVecConverter,
-    EcssTcReceiver, EcssTmSender, GenericConversionError, HandlingStatus, MpscTcReceiver,
-    PusServiceHelper,
+    CacheAndReadRawEcssTc, EcssTcInSharedPoolCacher, EcssTcReceiver, EcssTcVecCacher, EcssTmSender,
+    GenericConversionError, HandlingStatus, MpscTcReceiver, PusServiceHelper,
 };

 /// This is a helper class for [std] environments to handle generic PUS 17 (test service) packets.
@@ -19,7 +18,7 @@ use super::{
 pub struct PusService17TestHandler<
    TcReceiver: EcssTcReceiver,
    TmSender: EcssTmSender,
-    TcInMemConverter: EcssTcInMemConversionProvider,
+    TcInMemConverter: CacheAndReadRawEcssTc,
    VerificationReporter: VerificationReportingProvider,
 > {
    pub service_helper:
@@ -27,11 +26,11 @@ pub struct PusService17TestHandler<
 }

 impl<
-        TcReceiver: EcssTcReceiver,
-        TmSender: EcssTmSender,
-        TcInMemConverter: EcssTcInMemConversionProvider,
-        VerificationReporter: VerificationReportingProvider,
-    > PusService17TestHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
+    TcReceiver: EcssTcReceiver,
+    TmSender: EcssTmSender,
+    TcInMemConverter: CacheAndReadRawEcssTc,
+    VerificationReporter: VerificationReportingProvider,
+> PusService17TestHandler<TcReceiver, TmSender, TcInMemConverter, VerificationReporter>
 {
    pub fn new(
        service_helper: PusServiceHelper<
@@ -112,7 +111,7 @@ impl<
 pub type PusService17TestHandlerDynWithMpsc = PusService17TestHandler<
    MpscTcReceiver,
    mpsc::Sender<PacketAsVec>,
-    EcssTcInVecConverter,
+    EcssTcVecCacher,
    VerificationReporter,
 >;
 /// Helper type definition for a PUS 17 handler with a dynamic TMTC memory backend and bounded MPSC
@@ -120,7 +119,7 @@ pub type PusService17TestHandlerDynWithMpsc = PusService17TestHandler<
 pub type PusService17TestHandlerDynWithBoundedMpsc = PusService17TestHandler<
    MpscTcReceiver,
    mpsc::SyncSender<PacketAsVec>,
-    EcssTcInVecConverter,
+    EcssTcVecCacher,
    VerificationReporter,
 >;
 /// Helper type definition for a PUS 17 handler with a shared store TMTC memory backend and bounded
@@ -128,12 +127,13 @@ pub type PusService17TestHandlerDynWithBoundedMpsc = PusService17TestHandler<
 pub type PusService17TestHandlerStaticWithBoundedMpsc = PusService17TestHandler<
    MpscTcReceiver,
    PacketSenderWithSharedPool,
-    EcssTcInSharedPoolConverter,
+    EcssTcInSharedPoolCacher,
    VerificationReporter,
 >;

 #[cfg(test)]
 mod tests {
+    use crate::ComponentId;
    use crate::pus::test_util::{PusTestHarness, SimplePusPacketHandler, TEST_APID};
    use crate::pus::tests::{
        PusServiceHandlerWithSharedStoreCommon, PusServiceHandlerWithVecCommon,
@@ -143,18 +143,17 @@ mod tests {
    };
    use crate::pus::verification::{TcStateAccepted, VerificationToken};
    use crate::pus::{
-        DirectPusPacketHandlerResult, EcssTcInSharedPoolConverter, EcssTcInVecConverter,
+        DirectPusPacketHandlerResult, EcssTcInSharedPoolCacher, EcssTcVecCacher,
        GenericConversionError, HandlingStatus, MpscTcReceiver, MpscTmAsVecSender,
        PartialPusHandlingError, PusPacketHandlingError,
    };
    use crate::tmtc::PacketSenderWithSharedPool;
-    use crate::ComponentId;
    use delegate::delegate;
+    use spacepackets::SpHeader;
+    use spacepackets::ecss::PusPacket;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
    use spacepackets::ecss::tm::PusTmReader;
-    use spacepackets::ecss::PusPacket;
-    use spacepackets::time::{cds, TimeWriter};
-    use spacepackets::SpHeader;
+    use spacepackets::time::{TimeWriter, cds};

    use super::PusService17TestHandler;

@@ -163,7 +162,7 @@ mod tests {
        handler: PusService17TestHandler<
            MpscTcReceiver,
            PacketSenderWithSharedPool,
-            EcssTcInSharedPoolConverter,
+            EcssTcInSharedPoolCacher,
            VerificationReporter,
        >,
    }
@@ -180,8 +179,12 @@ mod tests {
    }

    impl PusTestHarness for Pus17HandlerWithStoreTester {
-        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let init_token = self.handler.service_helper.verif_reporter_mut().add_tc(tc);
+        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+            let init_token = self
+                .handler
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
            self.handler
                .service_helper
                .verif_reporter()
@@ -221,7 +224,7 @@ mod tests {
        handler: PusService17TestHandler<
            MpscTcReceiver,
            MpscTmAsVecSender,
-            EcssTcInVecConverter,
+            EcssTcVecCacher,
            VerificationReporter,
        >,
    }
@@ -238,8 +241,12 @@ mod tests {
    }

    impl PusTestHarness for Pus17HandlerWithVecTester {
-        fn init_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let init_token = self.handler.service_helper.verif_reporter_mut().add_tc(tc);
+        fn start_verification(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
+            let init_token = self
+                .handler
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
            self.handler
                .service_helper
                .verif_reporter()
@@ -279,7 +286,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let request_id = token.request_id();
        let result = test_harness.handle_one_tc();
@@ -334,7 +341,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(3, 1);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_err());
@@ -355,7 +362,7 @@ mod tests {
        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
        let sec_header = PusTcSecondaryHeader::new_simple(17, 200);
        let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true);
-        let token = test_harness.init_verification(&ping_tc);
+        let token = test_harness.start_verification(&ping_tc);
        test_harness.send_tc(&token, &ping_tc);
        let result = test_harness.handle_one_tc();
        assert!(result.is_ok());
--- a/satrs/src/pus/verification.rs
+++ b/satrs/src/pus/verification.rs
@@ -17,7 +17,7 @@
 //! use std::time::Duration;
 //! use satrs::pool::{PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
 //! use satrs::pus::verification::{
-//!     VerificationReportingProvider, VerificationReporterCfg, VerificationReporter
+//!     VerificationReportingProvider, VerificationReporterConfig, VerificationReporter
 //! };
 //! use satrs::tmtc::{SharedStaticMemoryPool, PacketSenderWithSharedPool};
 //! use satrs::spacepackets::seq_count::SeqCountProviderSimple;
@@ -38,7 +38,7 @@
 //! let shared_tm_pool = SharedStaticMemoryPool::new(RwLock::new(tm_pool));
 //! let (verif_tx, verif_rx) = mpsc::sync_channel(10);
 //! let sender = PacketSenderWithSharedPool::new_with_shared_packet_pool(verif_tx, &shared_tm_pool);
-//! let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+//! let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
 //! let mut  reporter = VerificationReporter::new(TEST_COMPONENT_ID.id(), &cfg);
 //!
 //! let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
@@ -47,7 +47,7 @@
 //!     tc_header,
 //!     true
 //! );
-//! let init_token = reporter.add_tc(&pus_tc_0);
+//! let init_token = reporter.start_verification(&pus_tc_0);
 //!
 //! // Complete success sequence for a telecommand
 //! let accepted_token = reporter.acceptance_success(&sender, init_token, &EMPTY_STAMP).unwrap();
@@ -65,8 +65,7 @@
 //!         let store_guard = rg.read_with_guard(tm_in_store.store_addr);
 //!         tm_len = store_guard.read(&mut tm_buf).expect("Error reading TM slice");
 //!     }
-//!     let (pus_tm, _) = PusTmReader::new(&tm_buf[0..tm_len], 7)
-//!        .expect("Error reading verification TM");
+//!     let pus_tm = PusTmReader::new(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
 //!     if packet_idx == 0 {
 //!         assert_eq!(pus_tm.subservice(), 1);
 //!     } else if packet_idx == 1 {
@@ -82,7 +81,7 @@
 //! for the verification module contains examples how this module could be used in a more complex
 //! context involving multiple threads
 use crate::params::{Params, WritableToBeBytes};
-use crate::pus::{source_buffer_large_enough, EcssTmSender, EcssTmtcError};
+use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough};
 use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
@@ -91,11 +90,11 @@ use core::mem::size_of;
 use delegate::delegate;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use spacepackets::ecss::EcssEnumeration;
 use spacepackets::ecss::tc::IsPusTelecommand;
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::ecss::EcssEnumeration;
 use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceCtrl};
-use spacepackets::{SpHeader, MAX_APID};
+use spacepackets::{MAX_APID, SpHeader};

 pub use spacepackets::ecss::verification::*;
 pub use spacepackets::seq_count::SeqCountProviderSimple;
@@ -103,8 +102,8 @@ pub use spacepackets::seq_count::SeqCountProviderSimple;
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;

-use crate::request::Apid;
 use crate::ComponentId;
+use crate::request::Apid;

 /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard.
 ///
@@ -228,7 +227,7 @@ pub struct VerificationToken<STATE> {
 }

 impl<STATE> VerificationToken<STATE> {
-    fn new(req_id: RequestId) -> VerificationToken<TcStateNone> {
+    pub fn new(req_id: RequestId) -> VerificationToken<TcStateNone> {
        VerificationToken {
            state: PhantomData,
            request_id: req_id,
@@ -408,14 +407,10 @@ pub trait VerificationReportingProvider {
    fn set_apid(&mut self, apid: Apid);
    fn apid(&self) -> Apid;

-    fn add_tc(
-        &mut self,
+    fn start_verification(
+        &self,
        pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
-    ) -> VerificationToken<TcStateNone> {
-        self.add_tc_with_req_id(RequestId::new(pus_tc))
-    }
-
-    fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
+    ) -> VerificationToken<TcStateNone>;

    fn acceptance_success(
        &self,
@@ -482,7 +477,7 @@ pub trait VerificationReportingProvider {
 /// the buffer passed to the API exposes by this struct will be used to serialize the source data.
 /// This buffer may not be re-used to serialize the whole telemetry because that would overwrite
 /// the source data itself.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct VerificationReportCreator {
    pub dest_id: u16,
    apid: u16,
@@ -516,26 +511,15 @@ impl VerificationReportCreator {
        self.dest_id = dest_id;
    }

-    /// Initialize verification handling by passing a TC reference. This returns a token required
-    /// to call the acceptance functions
-    pub fn add_tc(
-        &mut self,
-        pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
-    ) -> VerificationToken<TcStateNone> {
-        self.add_tc_with_req_id(RequestId::new(pus_tc))
+    pub fn read_request_id(&self, pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> RequestId {
+        RequestId::new(pus_tc)
    }

-    /// Same as [Self::add_tc] but pass a request ID instead of the direct telecommand.
-    /// This can be useful if the executing thread does not have full access to the telecommand.
-    pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone> {
-        VerificationToken::<TcStateNone>::new(req_id)
-    }
-
-    fn success_verification_no_step<'time, 'src_data, State: Copy>(
+    fn success_verification_no_step<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
-        token: VerificationToken<State>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        time_stamp: &'time [u8],
@@ -545,7 +529,7 @@ impl VerificationReportCreator {
            subservice,
            seq_count,
            msg_count,
-            &token.request_id(),
+            request_id,
            time_stamp,
            None::<&dyn EcssEnumeration>,
        )?;
@@ -554,11 +538,11 @@ impl VerificationReportCreator {

    // Internal helper function, too many arguments is acceptable for this case.
    #[allow(clippy::too_many_arguments)]
-    fn failure_verification_no_step<'time, 'src_data, State: Copy>(
+    fn failure_verification_no_step<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
        subservice: u8,
-        token: VerificationToken<State>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        step: Option<&(impl EcssEnumeration + ?Sized)>,
@@ -569,7 +553,7 @@ impl VerificationReportCreator {
            subservice,
            seq_count,
            msg_count,
-            &token.request_id(),
+            request_id,
            step,
            params,
        )?;
@@ -580,39 +564,27 @@ impl VerificationReportCreator {
    pub fn acceptance_success<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcStateNone>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        time_stamp: &'time [u8],
-    ) -> Result<
-        (
-            PusTmCreator<'time, 'src_data>,
-            VerificationToken<TcStateAccepted>,
-        ),
-        ByteConversionError,
-    > {
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        let tm_creator = self.success_verification_no_step(
            src_data_buf,
            Subservice::TmAcceptanceSuccess.into(),
-            token,
+            request_id,
            seq_count,
            msg_count,
            time_stamp,
        )?;
-        Ok((
-            tm_creator,
-            VerificationToken {
-                state: PhantomData,
-                request_id: token.request_id(),
-            },
-        ))
+        Ok(tm_creator)
    }

    /// Package a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard.
    pub fn acceptance_failure<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcStateNone>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        params: FailParams<'time, '_>,
@@ -620,7 +592,7 @@ impl VerificationReportCreator {
        self.failure_verification_no_step(
            src_data_buf,
            Subservice::TmAcceptanceFailure.into(),
-            token,
+            request_id,
            seq_count,
            msg_count,
            None::<&dyn EcssEnumeration>,
@@ -634,32 +606,20 @@ impl VerificationReportCreator {
    pub fn start_success<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcStateAccepted>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        time_stamp: &'time [u8],
-    ) -> Result<
-        (
-            PusTmCreator<'time, 'src_data>,
-            VerificationToken<TcStateStarted>,
-        ),
-        ByteConversionError,
-    > {
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        let tm_creator = self.success_verification_no_step(
            src_data_buf,
            Subservice::TmStartSuccess.into(),
-            token,
+            request_id,
            seq_count,
            msg_count,
            time_stamp,
        )?;
-        Ok((
-            tm_creator,
-            VerificationToken {
-                state: PhantomData,
-                request_id: token.request_id(),
-            },
-        ))
+        Ok(tm_creator)
    }

    /// Package and send a PUS TM\[1, 4\] packet, see 8.1.2.4 of the PUS standard.
@@ -669,7 +629,7 @@ impl VerificationReportCreator {
    pub fn start_failure<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcStateAccepted>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        params: FailParams<'time, '_>,
@@ -677,7 +637,7 @@ impl VerificationReportCreator {
        self.failure_verification_no_step(
            src_data_buf,
            Subservice::TmStartFailure.into(),
-            token,
+            request_id,
            seq_count,
            msg_count,
            None::<&dyn EcssEnumeration>,
@@ -691,7 +651,7 @@ impl VerificationReportCreator {
    pub fn step_success<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: &VerificationToken<TcStateStarted>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        time_stamp: &'time [u8],
@@ -702,7 +662,7 @@ impl VerificationReportCreator {
            Subservice::TmStepSuccess.into(),
            seq_count,
            msg_count,
-            &token.request_id(),
+            request_id,
            time_stamp,
            Some(&step),
        )
@@ -735,10 +695,10 @@ impl VerificationReportCreator {
    ///
    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
    /// token because verification handling is done.
-    pub fn completion_success<'time, 'src_data, TcState: WasAtLeastAccepted + Copy>(
+    pub fn completion_success<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcState>,
+        request_id: &RequestId,
        seq_counter: u16,
        msg_counter: u16,
        time_stamp: &'time [u8],
@@ -746,7 +706,7 @@ impl VerificationReportCreator {
        self.success_verification_no_step(
            src_data_buf,
            Subservice::TmCompletionSuccess.into(),
-            token,
+            request_id,
            seq_counter,
            msg_counter,
            time_stamp,
@@ -757,10 +717,10 @@ impl VerificationReportCreator {
    ///
    /// Requires a token previously acquired by calling [Self::start_success]. It consumes the
    /// token because verification handling is done.
-    pub fn completion_failure<'time, 'src_data, TcState: WasAtLeastAccepted + Copy>(
+    pub fn completion_failure<'time, 'src_data>(
        &self,
        src_data_buf: &'src_data mut [u8],
-        token: VerificationToken<TcState>,
+        request_id: &RequestId,
        seq_count: u16,
        msg_count: u16,
        params: FailParams<'time, '_>,
@@ -768,7 +728,7 @@ impl VerificationReportCreator {
        self.failure_verification_no_step(
            src_data_buf,
            Subservice::TmCompletionFailure.into(),
-            token,
+            request_id,
            seq_count,
            msg_count,
            None::<&dyn EcssEnumeration>,
@@ -884,14 +844,14 @@ pub mod alloc_mod {
    use core::cell::RefCell;

    #[derive(Clone)]
-    pub struct VerificationReporterCfg {
+    pub struct VerificationReporterConfig {
        apid: u16,
        pub step_field_width: usize,
        pub fail_code_field_width: usize,
        pub max_fail_data_len: usize,
    }

-    impl VerificationReporterCfg {
+    impl VerificationReporterConfig {
        pub fn new(
            apid: u16,
            step_field_width: usize,
@@ -914,7 +874,7 @@ pub mod alloc_mod {
    ///
    /// The [Self::modify_tm] function is called before the TM is sent. This allows users to change
    /// fields like the message count or sequence counter before the TM is sent.
-    pub trait VerificationHookProvider {
+    pub trait VerificationHook {
        fn modify_tm(&self, tm: &mut PusTmCreator);
    }

@@ -924,7 +884,7 @@ pub mod alloc_mod {
    #[derive(Default, Copy, Clone)]
    pub struct DummyVerificationHook {}

-    impl VerificationHookProvider for DummyVerificationHook {
+    impl VerificationHook for DummyVerificationHook {
        fn modify_tm(&self, _tm: &mut PusTmCreator) {}
    }

@@ -937,16 +897,16 @@ pub mod alloc_mod {
    /// destination fields are assumed to be constant for a given repoter instance.
    #[derive(Clone)]
    pub struct VerificationReporter<
-        VerificationHook: VerificationHookProvider = DummyVerificationHook,
+        VerificationHookInstance: VerificationHook = DummyVerificationHook,
    > {
        owner_id: ComponentId,
        source_data_buf: RefCell<alloc::vec::Vec<u8>>,
-        pub reporter_creator: VerificationReportCreator,
-        pub tm_hook: VerificationHook,
+        pub report_creator: VerificationReportCreator,
+        pub tm_hook: VerificationHookInstance,
    }

    impl VerificationReporter<DummyVerificationHook> {
-        pub fn new(owner_id: ComponentId, cfg: &VerificationReporterCfg) -> Self {
+        pub fn new(owner_id: ComponentId, cfg: &VerificationReporterConfig) -> Self {
            let reporter = VerificationReportCreator::new(cfg.apid).unwrap();
            Self {
                owner_id,
@@ -957,19 +917,19 @@ pub mod alloc_mod {
                        + cfg.fail_code_field_width
                        + cfg.max_fail_data_len
                ]),
-                reporter_creator: reporter,
+                report_creator: reporter,
                tm_hook: DummyVerificationHook::default(),
            }
        }
    }

-    impl<VerificationHook: VerificationHookProvider> VerificationReporter<VerificationHook> {
+    impl<VerificationHookInstance: VerificationHook> VerificationReporter<VerificationHookInstance> {
        /// The provided [VerificationHookProvider] can be used to modify a verification packet
        /// before it is sent.
        pub fn new_with_hook(
            owner_id: ComponentId,
-            cfg: &VerificationReporterCfg,
-            tm_hook: VerificationHook,
+            cfg: &VerificationReporterConfig,
+            tm_hook: VerificationHookInstance,
        ) -> Self {
            let reporter = VerificationReportCreator::new(cfg.apid).unwrap();
            Self {
@@ -981,17 +941,29 @@ pub mod alloc_mod {
                        + cfg.fail_code_field_width
                        + cfg.max_fail_data_len
                ]),
-                reporter_creator: reporter,
+                report_creator: reporter,
                tm_hook,
            }
        }

+        pub fn start_verification(
+            &self,
+            pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
+        ) -> VerificationToken<TcStateNone> {
+            VerificationToken::<TcStateNone>::new(self.report_creator.read_request_id(pus_tc))
+        }
+
+        pub fn start_verification_with_req_id(
+            &self,
+            request_id: RequestId,
+        ) -> VerificationToken<TcStateNone> {
+            VerificationToken::<TcStateNone>::new(request_id)
+        }
+
        delegate!(
-            to self.reporter_creator {
+            to self.report_creator {
                pub fn set_apid(&mut self, apid: u16) -> bool;
                pub fn apid(&self) -> u16;
-                pub fn add_tc(&mut self, pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> VerificationToken<TcStateNone>;
-                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
                pub fn dest_id(&self) -> u16;
                pub fn set_dest_id(&mut self, dest_id: u16);
            }
@@ -1002,18 +974,23 @@ pub mod alloc_mod {
        }
    }

-    impl<VerificationHook: VerificationHookProvider> VerificationReportingProvider
-        for VerificationReporter<VerificationHook>
+    impl<VerificationHookInstance: VerificationHook> VerificationReportingProvider
+        for VerificationReporter<VerificationHookInstance>
    {
        delegate!(
-            to self.reporter_creator {
+            to self.report_creator {
                fn set_apid(&mut self, apid: Apid);
                fn apid(&self) -> Apid;
-                fn add_tc(&mut self, pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> VerificationToken<TcStateNone>;
-                fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
            }
        );

+        fn start_verification(
+            &self,
+            pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
+        ) -> VerificationToken<TcStateNone> {
+            VerificationToken::<TcStateNone>::new(RequestId::new(pus_tc))
+        }
+
        fn owner_id(&self) -> ComponentId {
            self.owner_id
        }
@@ -1026,13 +1003,19 @@ pub mod alloc_mod {
            time_stamp: &[u8],
        ) -> Result<VerificationToken<TcStateAccepted>, EcssTmtcError> {
            let mut source_data_buf = self.source_data_buf.borrow_mut();
-            let (mut tm_creator, token) = self
-                .reporter_creator
-                .acceptance_success(source_data_buf.as_mut_slice(), token, 0, 0, time_stamp)
+            let mut tm_creator = self
+                .report_creator
+                .acceptance_success(
+                    source_data_buf.as_mut_slice(),
+                    &token.request_id(),
+                    0,
+                    0,
+                    time_stamp,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
-            Ok(token)
+            Ok(VerificationToken::new_accepted_state(token.request_id()))
        }

        /// Package and send a PUS TM\[1, 2\] packet, see 8.1.2.2 of the PUS standard
@@ -1044,8 +1027,8 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
-                .acceptance_failure(buf.as_mut_slice(), token, 0, 0, params)
+                .report_creator
+                .acceptance_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1062,13 +1045,13 @@ pub mod alloc_mod {
            time_stamp: &[u8],
        ) -> Result<VerificationToken<TcStateStarted>, EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
-            let (mut tm_creator, started_token) = self
-                .reporter_creator
-                .start_success(buf.as_mut_slice(), token, 0, 0, time_stamp)
+            let mut tm_creator = self
+                .report_creator
+                .start_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
-            Ok(started_token)
+            Ok(VerificationToken::new_started_state(token.request_id()))
        }

        /// Package and send a PUS TM\[1, 4\] packet, see 8.1.2.4 of the PUS standard.
@@ -1083,8 +1066,8 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
-                .start_failure(buf.as_mut_slice(), token, 0, 0, params)
+                .report_creator
+                .start_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1103,8 +1086,15 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
-                .step_success(buf.as_mut_slice(), token, 0, 0, time_stamp, step)
+                .report_creator
+                .step_success(
+                    buf.as_mut_slice(),
+                    &token.request_id(),
+                    0,
+                    0,
+                    time_stamp,
+                    step,
+                )
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1123,7 +1113,7 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
+                .report_creator
                .step_failure(buf.as_mut_slice(), token, 0, 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
@@ -1144,8 +1134,8 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
-                .completion_success(buf.as_mut_slice(), token, 0, 0, time_stamp)
+                .report_creator
+                .completion_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id, PusTmVariant::Direct(tm_creator))?;
@@ -1164,8 +1154,8 @@ pub mod alloc_mod {
        ) -> Result<(), EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
-                .completion_failure(buf.as_mut_slice(), token, 0, 00, params)
+                .report_creator
+                .completion_failure(buf.as_mut_slice(), &token.request_id(), 0, 00, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
            sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1362,22 +1352,23 @@ pub mod test_util {
    }

    impl VerificationReportingProvider for TestVerificationReporter {
+        fn start_verification(
+            &self,
+            pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
+        ) -> VerificationToken<TcStateNone> {
+            let request_id = RequestId::new(pus_tc);
+            self.report_queue
+                .borrow_mut()
+                .push_back((request_id, VerificationReportInfo::Added));
+            VerificationToken::<TcStateNone>::new(RequestId::new(pus_tc))
+        }
+
        fn set_apid(&mut self, _apid: Apid) {}

        fn apid(&self) -> Apid {
            0
        }

-        fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone> {
-            self.report_queue
-                .borrow_mut()
-                .push_back((req_id, VerificationReportInfo::Added));
-            VerificationToken {
-                state: PhantomData,
-                request_id: req_id,
-            }
-        }
-
        fn acceptance_success(
            &self,
            _sender: &(impl EcssTmSender + ?Sized),
@@ -1691,39 +1682,39 @@ pub mod test_util {

 #[cfg(test)]
 pub mod tests {
+    use crate::ComponentId;
    use crate::params::Params;
    use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
    use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
    use crate::pus::tests::CommonTmInfo;
    use crate::pus::verification::{
-        handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams,
-        FailParamsWithStep, RequestId, TcStateNone, VerificationReporter, VerificationReporterCfg,
-        VerificationToken,
+        EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone,
+        VerificationReporter, VerificationReporterConfig, VerificationToken,
+        handle_step_failure_with_generic_params,
    };
    use crate::pus::{ChannelWithId, PusTmVariant};
    use crate::request::MessageMetadata;
    use crate::spacepackets::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProvider};
    use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
-    use crate::ComponentId;
    use alloc::format;
    use alloc::string::ToString;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::{
-        EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket,
+        EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket,
        WritablePusPacket,
    };
    use spacepackets::util::UnsignedEnum;
    use spacepackets::{ByteConversionError, SpHeader};
    use std::cell::RefCell;
    use std::collections::VecDeque;
-    use std::sync::{mpsc, RwLock};
+    use std::sync::{RwLock, mpsc};
    use std::vec;
    use std::vec::Vec;

    use super::{
-        handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper,
-        SeqCountProviderSimple, TcStateAccepted, TcStateStarted, VerificationHookProvider,
-        VerificationReportingProvider, WasAtLeastAccepted,
+        DummyVerificationHook, FailParamHelper, SeqCountProviderSimple, TcStateAccepted,
+        TcStateStarted, VerificationHook, VerificationReportingProvider, WasAtLeastAccepted,
+        handle_completion_failure_with_generic_params,
    };

    fn is_send<T: Send>(_: &T) {}
@@ -1792,7 +1783,7 @@ pub mod tests {
        pub msg_counter: SeqCountProviderSimple<u16>,
    }

-    impl VerificationHookProvider for SequenceCounterHook {
+    impl VerificationHook for SequenceCounterHook {
        fn modify_tm(&self, tm: &mut spacepackets::ecss::tm::PusTmCreator) {
            tm.set_seq_count(self.seq_counter.get_and_increment());
            tm.set_msg_counter(self.msg_counter.get_and_increment());
@@ -1800,29 +1791,29 @@ pub mod tests {
    }

    struct VerificationReporterTestbench<
-        VerificationHook: VerificationHookProvider = DummyVerificationHook,
+        VerificationHookInstance: VerificationHook = DummyVerificationHook,
    > {
        pub id: ComponentId,
        sender: TestSender,
-        reporter: VerificationReporter<VerificationHook>,
+        reporter: VerificationReporter<VerificationHookInstance>,
        pub request_id: RequestId,
        tc: Vec<u8>,
    }

    fn base_reporter(id: ComponentId, max_fail_data_len: usize) -> VerificationReporter {
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, max_fail_data_len).unwrap();
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, max_fail_data_len).unwrap();
        VerificationReporter::new(id, &cfg)
    }

-    fn reporter_with_hook<VerificationHook: VerificationHookProvider>(
+    fn reporter_with_hook<VerificationHookInstance: VerificationHook>(
        id: ComponentId,
-        hook: VerificationHook,
-    ) -> VerificationReporter<VerificationHook> {
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        hook: VerificationHookInstance,
+    ) -> VerificationReporter<VerificationHookInstance> {
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
        VerificationReporter::new_with_hook(id, &cfg, hook)
    }

-    impl<VerificiationHook: VerificationHookProvider> VerificationReporterTestbench<VerificiationHook> {
+    impl<VerificiationHook: VerificationHook> VerificationReporterTestbench<VerificiationHook> {
        fn new_with_hook(id: ComponentId, tc: PusTcCreator, tm_hook: VerificiationHook) -> Self {
            let reporter = reporter_with_hook(id, tm_hook);
            Self {
@@ -1834,15 +1825,16 @@ pub mod tests {
            }
        }

+        pub fn start_verification(&self) -> VerificationToken<TcStateNone> {
+            let tc_reader = PusTcReader::new(&self.tc).unwrap();
+            self.reporter.start_verification(&tc_reader)
+        }
+
        #[allow(dead_code)]
        fn set_dest_id(&mut self, dest_id: u16) {
            self.reporter.set_dest_id(dest_id);
        }

-        fn init(&mut self) -> VerificationToken<TcStateNone> {
-            self.reporter.add_tc(&PusTcReader::new(&self.tc).unwrap().0)
-        }
-
        fn acceptance_success(
            &self,
            token: VerificationToken<TcStateNone>,
@@ -1920,7 +1912,7 @@ pub mod tests {
                additional_data: None,
            };
            let mut service_queue = self.sender.service_queue.borrow_mut();
-            assert!(service_queue.len() >= 1);
+            assert!(!service_queue.is_empty());
            let info = service_queue.pop_front().unwrap();
            assert_eq!(info, cmp_info);
        }
@@ -2092,8 +2084,8 @@ pub mod tests {

    #[test]
    fn test_basic_acceptance_success() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.init();
+        let testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let token = testbench.start_verification();
        testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("sending acceptance success failed");
@@ -2103,7 +2095,7 @@ pub mod tests {
    #[test]
    fn test_basic_acceptance_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.init();
+        let init_token = testbench.start_verification();
        let timestamp = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
@@ -2116,7 +2108,7 @@ pub mod tests {
    #[test]
    fn test_basic_acceptance_failure_with_helper() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.init();
+        let init_token = testbench.start_verification();
        let timestamp = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
@@ -2128,8 +2120,8 @@ pub mod tests {

    #[test]
    fn test_acceptance_fail_data_too_large() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 8);
-        let init_token = testbench.init();
+        let testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 8);
+        let init_token = testbench.start_verification();
        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
        let fail_code = EcssEnumU16::new(2);
        let fail_data: [u8; 16] = [0; 16];
@@ -2160,13 +2152,13 @@ pub mod tests {

    #[test]
    fn test_basic_acceptance_failure_with_fail_data() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
+        let testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
        let fail_code = EcssEnumU8::new(10);
        let fail_data = EcssEnumU32::new(12);
        let mut fail_data_raw = [0; 4];
        fail_data.write_to_be_bytes(&mut fail_data_raw).unwrap();
        let fail_params = FailParams::new(&EMPTY_STAMP, &fail_code, fail_data_raw.as_slice());
-        let init_token = testbench.init();
+        let init_token = testbench.start_verification();
        testbench
            .acceptance_failure(init_token, fail_params)
            .expect("sending acceptance failure failed");
@@ -2184,7 +2176,7 @@ pub mod tests {
    #[test]
    fn test_start_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let init_token = testbench.init();
+        let init_token = testbench.start_verification();
        let fail_code = EcssEnumU8::new(22);
        let fail_data: i32 = -12;
        let mut fail_data_raw = [0; 4];
@@ -2203,7 +2195,7 @@ pub mod tests {
    #[test]
    fn test_start_failure_with_helper() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let fail_code = EcssEnumU8::new(22);
        let fail_data: i32 = -12;
        let mut fail_data_raw = [0; 4];
@@ -2222,7 +2214,7 @@ pub mod tests {
    #[test]
    fn test_steps_success() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("acceptance  failed");
@@ -2245,7 +2237,7 @@ pub mod tests {
    #[test]
    fn test_step_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let fail_code = EcssEnumU32::new(0x1020);
        let fail_data: f32 = -22.3232;
        let mut fail_data_raw = [0; 4];
@@ -2279,7 +2271,7 @@ pub mod tests {
    #[test]
    fn test_completion_failure() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let fail_code = EcssEnumU32::new(0x1020);
        let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);

@@ -2302,7 +2294,7 @@ pub mod tests {
    fn test_complete_success_sequence() {
        let mut testbench =
            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping(), 16);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2324,7 +2316,7 @@ pub mod tests {
            create_generic_ping(),
            SequenceCounterHook::default(),
        );
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2342,7 +2334,7 @@ pub mod tests {
    #[test]
    fn test_completion_failure_helper_string_param() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
@@ -2369,7 +2361,7 @@ pub mod tests {
    #[test]
    fn test_step_failure_helper_string_param() {
        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
-        let token = testbench.init();
+        let token = testbench.start_verification();
        let accepted_token = testbench
            .acceptance_success(token, &EMPTY_STAMP)
            .expect("Sending acceptance success failed");
--- a/satrs/src/request.rs
+++ b/satrs/src/request.rs
@@ -9,13 +9,13 @@ pub use alloc_mod::*;
 pub use std_mod::*;

 use spacepackets::{
-    ecss::{tc::IsPusTelecommand, PusPacket},
    ByteConversionError,
+    ecss::{PusPacket, tc::IsPusTelecommand},
 };

 use crate::{
-    queue::{GenericReceiveError, GenericSendError},
    ComponentId,
+    queue::{GenericReceiveError, GenericSendError},
 };

 /// Generic request ID type. Requests can be associated with an ID to have a unique identifier
@@ -335,12 +335,12 @@ pub mod alloc_mod {
    }

    impl<
-            To,
-            From,
-            Sender: MessageSenderProvider<To>,
-            Receiver: MessageReceiverProvider<From>,
-            SenderStore: MessageSenderStoreProvider<To, Sender>,
-        > MessageSenderAndReceiver<To, From, Sender, Receiver, SenderStore>
+        To,
+        From,
+        Sender: MessageSenderProvider<To>,
+        Receiver: MessageReceiverProvider<From>,
+        SenderStore: MessageSenderStoreProvider<To, Sender>,
+    > MessageSenderAndReceiver<To, From, Sender, Receiver, SenderStore>
    {
        pub fn new(local_channel_id: ComponentId, message_receiver: Receiver) -> Self {
            Self {
@@ -403,15 +403,15 @@ pub mod alloc_mod {
    }

    impl<
-            Request,
-            ReqSender: MessageSenderProvider<Request>,
-            ReqReceiver: MessageReceiverProvider<Request>,
-            ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
-            Reply,
-            ReplySender: MessageSenderProvider<Reply>,
-            ReplyReceiver: MessageReceiverProvider<Reply>,
-            ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
-        >
+        Request,
+        ReqSender: MessageSenderProvider<Request>,
+        ReqReceiver: MessageReceiverProvider<Request>,
+        ReqSenderStore: MessageSenderStoreProvider<Request, ReqSender>,
+        Reply,
+        ReplySender: MessageSenderProvider<Reply>,
+        ReplyReceiver: MessageReceiverProvider<Reply>,
+        ReplySenderStore: MessageSenderStoreProvider<Reply, ReplySender>,
+    >
        RequestAndReplySenderAndReceiver<
            Request,
            ReqSender,
@@ -497,8 +497,8 @@ mod tests {

    use alloc::string::ToString;
    use spacepackets::{
-        ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
        ByteConversionError, SpHeader,
+        ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
    };

    use crate::{
--- a/satrs/src/scheduling.rs
+++ b/satrs/src/scheduling.rs
@@ -211,8 +211,8 @@ mod tests {
        println,
        rc::Rc,
        sync::{
-            mpsc::{self, TryRecvError},
            Arc, Mutex,
+            mpsc::{self, TryRecvError},
        },
        time::Instant,
    };
--- a/satrs/src/subsystem.rs
+++ b/satrs/src/subsystem.rs
@@ -1,4 +1,5 @@
 use crate::{
+    ComponentId,
    health::{HealthState, HealthTableProvider},
    mode::{Mode, ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender, UNKNOWN_MODE_VAL},
    mode_tree::{
@@ -7,7 +8,6 @@ use crate::{
    },
    queue::GenericTargetedMessagingError,
    request::{GenericMessage, RequestId},
-    ComponentId,
 };

 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
@@ -136,7 +136,7 @@ impl SequenceExecutionHelper {
    ///   with [Self::load]
    /// * `sender` - The sender to send mode requests to the components
    /// * `children_mode_store` - The mode store vector to keep track of the mode states of
-    ///    children components
+    ///   children components
    pub fn run(
        &mut self,
        table: &SequenceModeTables,
@@ -252,10 +252,10 @@ impl SequenceExecutionHelper {
            Ok(ModeCommandingResult::AwaitingSuccessCheck)
        } else if seq_table_value.entries.len() - 1 == sequence_idx {
            self.state = SequenceExecutionHelperState::Idle;
-            return Ok(ModeCommandingResult::Done);
+            Ok(ModeCommandingResult::Done)
        } else {
            self.current_sequence_index = Some(sequence_idx + 1);
-            return Ok(ModeCommandingResult::StepDone);
+            Ok(ModeCommandingResult::StepDone)
        }
    }

@@ -597,7 +597,7 @@ impl SubsystemCommandingHelper {
    }

    fn update_internal_req_id(&mut self) {
-        let new_internal_req_id = self.request_id().unwrap() << 8
+        let new_internal_req_id = (self.request_id().unwrap() << 8)
            | self.seq_exec_helper.current_sequence_index().unwrap() as u32;
        self.seq_exec_helper.set_request_id(new_internal_req_id);
        self.active_internal_request_id = Some(new_internal_req_id);
@@ -682,9 +682,10 @@ mod tests {
    use super::*;

    use crate::{
+        ComponentId,
        mode::{
-            tests::{ModeReqSenderMock, ModeReqWrapper},
            Mode, ModeAndSubmode, ModeReply, ModeRequest, UNKNOWN_MODE,
+            tests::{ModeReqSenderMock, ModeReqWrapper},
        },
        mode_tree::{
            ModeStoreProvider, ModeStoreVec, SequenceModeTables, SequenceTableEntry,
@@ -693,7 +694,6 @@ mod tests {
        queue::GenericTargetedMessagingError,
        request::{GenericMessage, MessageMetadata, RequestId},
        subsystem::{ModeCommandingResult, ModeTreeHelperState, SequenceExecutionHelperState},
-        ComponentId,
    };

    #[derive(Debug)]
--- a/satrs/src/time.rs
+++ b/satrs/src/time.rs
@@ -1,7 +1,7 @@
 use core::fmt::Debug;

 /// Generic abstraction for a check/countdown timer.
-pub trait CountdownProvider: Debug {
+pub trait Countdown: Debug {
    fn has_expired(&self) -> bool;
    fn reset(&mut self);
 }
--- a/satrs/src/tmtc/mod.rs
+++ b/satrs/src/tmtc/mod.rs
@@ -9,20 +9,20 @@
 //! They only need to send the received and generated data to these objects.
 use crate::queue::GenericSendError;
 use crate::{
-    pool::{PoolAddr, PoolError},
    ComponentId,
+    pool::{PoolAddr, PoolError},
 };
 #[cfg(feature = "std")]
 pub use alloc_mod::*;
 use core::fmt::Debug;
 #[cfg(feature = "alloc")]
-use downcast_rs::{impl_downcast, Downcast};
+use downcast_rs::{Downcast, impl_downcast};
 use spacepackets::{
+    SpHeader,
    ecss::{
        tc::PusTcReader,
        tm::{PusTmCreator, PusTmReader},
    },
-    SpHeader,
 };
 #[cfg(feature = "std")]
 use std::sync::mpsc;
--- a/satrs/src/tmtc/tm_helper.rs
+++ b/satrs/src/tmtc/tm_helper.rs
@@ -1,7 +1,7 @@
-use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::time::cds::CdsTime;
-use spacepackets::time::TimeWriter;
 use spacepackets::SpHeader;
+use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
+use spacepackets::time::TimeWriter;
+use spacepackets::time::cds::CdsTime;

 pub struct PusTmWithCdsShortHelper {
    apid: u16,
@@ -56,7 +56,7 @@ impl PusTmWithCdsShortHelper {

 #[cfg(test)]
 mod tests {
-    use spacepackets::{ecss::PusPacket, time::cds::CdsTime, CcsdsPacket};
+    use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime};

    use super::PusTmWithCdsShortHelper;

--- a/satrs/tests/mode_tree.rs
+++ b/satrs/tests/mode_tree.rs
@@ -4,13 +4,13 @@ use satrs::dev_mgmt::{
    DevManagerCommandingHelper, DevManagerHelperResult, TransparentDevManagerHook,
 };
 use satrs::mode::{
-    Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler,
-    ModeRequestHandlerMpscBounded, ModeRequestReceiver, ModeRequestorAndHandlerMpscBounded,
-    ModeRequestorOneChildBoundedMpsc, INVALID_MODE, UNKNOWN_MODE,
+    INVALID_MODE, Mode, ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender,
+    ModeRequestHandler, ModeRequestHandlerMpscBounded, ModeRequestReceiver,
+    ModeRequestorAndHandlerMpscBounded, ModeRequestorOneChildBoundedMpsc, UNKNOWN_MODE,
 };
 use satrs::mode_tree::{
-    connect_mode_nodes, ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableEntry,
-    SequenceTableMapTable, TargetTableEntry,
+    ModeChild, ModeNode, ModeParent, ModeStoreProvider, SequenceTableEntry, SequenceTableMapTable,
+    TargetTableEntry, connect_mode_nodes,
 };
 use satrs::mode_tree::{SequenceTablesMapValue, TargetTablesMapValue};
 use satrs::request::{MessageMetadata, RequestId};
@@ -20,10 +20,10 @@ use satrs::subsystem::{
    StartSequenceError, SubsystemCommandingHelper, SubsystemHelperResult,
 };
 use satrs::{
+    ComponentId,
    mode::{ModeAndSubmode, ModeReply, ModeRequest},
    queue::GenericTargetedMessagingError,
    request::GenericMessage,
-    ComponentId,
 };
 use std::borrow::{Borrow, BorrowMut};
 use std::cell::RefCell;
--- a/satrs/tests/pus_events.rs
+++ b/satrs/tests/pus_events.rs
@@ -107,9 +107,9 @@ fn test_threaded_usage() {
                Ok(event_tm) => {
                    let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
                        .expect("Deserializing TM failed");
-                    assert_eq!(tm.0.service(), 5);
-                    assert_eq!(tm.0.subservice(), 1);
-                    let src_data = tm.0.source_data();
+                    assert_eq!(tm.service(), 5);
+                    assert_eq!(tm.subservice(), 1);
+                    let src_data = tm.source_data();
                    assert!(!src_data.is_empty());
                    assert_eq!(src_data.len(), 4);
                    let event =
@@ -137,9 +137,9 @@ fn test_threaded_usage() {
                Ok(event_tm) => {
                    let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
                        .expect("Deserializing TM failed");
-                    assert_eq!(tm.0.service(), 5);
-                    assert_eq!(tm.0.subservice(), 2);
-                    let src_data = tm.0.source_data();
+                    assert_eq!(tm.service(), 5);
+                    assert_eq!(tm.subservice(), 2);
+                    let src_data = tm.source_data();
                    assert!(!src_data.is_empty());
                    assert_eq!(src_data.len(), 12);
                    let event =
--- a/satrs/tests/pus_verification.rs
+++ b/satrs/tests/pus_verification.rs
@@ -4,14 +4,14 @@ pub mod crossbeam_test {
    use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
    use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
    use satrs::pus::verification::{
-        FailParams, RequestId, VerificationReporter, VerificationReporterCfg,
+        FailParams, RequestId, VerificationReporter, VerificationReporterConfig,
        VerificationReportingProvider,
    };
    use satrs::tmtc::{PacketSenderWithSharedPool, SharedStaticMemoryPool};
+    use spacepackets::SpHeader;
    use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
    use spacepackets::ecss::tm::PusTmReader;
-    use spacepackets::ecss::{EcssEnumU16, EcssEnumU8, PusPacket, WritablePusPacket};
-    use spacepackets::SpHeader;
+    use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, PusPacket, WritablePusPacket};
    use std::sync::RwLock;
    use std::thread;
    use std::time::Duration;
@@ -31,7 +31,7 @@ pub mod crossbeam_test {
        // We use a synced sequence count provider here because both verification reporters have the
        // the same APID. If they had distinct APIDs, the more correct approach would be to have
        // each reporter have an own sequence count provider.
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8).unwrap();
        // Shared pool object to store the verification PUS telemetry
        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
            vec![(10, 32), (10, 64), (10, 128), (10, 1024)],
@@ -46,8 +46,8 @@ pub mod crossbeam_test {
        let sender =
            PacketSenderWithSharedPool::new_with_shared_packet_pool(tx.clone(), &shared_tm_pool);
        let sender_1 = sender.clone();
-        let mut reporter_with_sender_0 = VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &cfg);
-        let mut reporter_with_sender_1 = reporter_with_sender_0.clone();
+        let reporter_with_sender_0 = VerificationReporter::new(TEST_COMPONENT_ID_0.id(), &cfg);
+        let reporter_with_sender_1 = reporter_with_sender_0.clone();
        // For test purposes, we retrieve the request ID from the TCs and pass them to the receiver
        // tread.
        let req_id_0;
@@ -89,9 +89,9 @@ pub mod crossbeam_test {
                let pg = tc_guard.read_with_guard(tc_addr);
                tc_len = pg.read(&mut tc_buf).unwrap();
            }
-            let (_tc, _) = PusTcReader::new(&tc_buf[0..tc_len]).unwrap();
+            let _tc = PusTcReader::new(&tc_buf[0..tc_len]).unwrap();

-            let token = reporter_with_sender_0.add_tc_with_req_id(req_id_0);
+            let token = reporter_with_sender_0.start_verification_with_req_id(req_id_0);
            let accepted_token = reporter_with_sender_0
                .acceptance_success(&sender, token, &FIXED_STAMP)
                .expect("Acceptance success failed");
@@ -125,8 +125,8 @@ pub mod crossbeam_test {
                let pg = tc_guard.read_with_guard(tc_addr);
                tc_len = pg.read(&mut tc_buf).unwrap();
            }
-            let (tc, _) = PusTcReader::new(&tc_buf[0..tc_len]).unwrap();
-            let token = reporter_with_sender_1.add_tc(&tc);
+            let tc = PusTcReader::new(&tc_buf[0..tc_len]).unwrap();
+            let token = reporter_with_sender_1.start_verification(&tc);
            let accepted_token = reporter_with_sender_1
                .acceptance_success(&sender_1, token, &FIXED_STAMP)
                .expect("Acceptance success failed");
@@ -156,7 +156,7 @@ pub mod crossbeam_test {
                        .read(&mut tm_buf)
                        .expect("Error reading TM slice");
                }
-                let (pus_tm, _) =
+                let pus_tm =
                    PusTmReader::new(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
                let req_id =
                    RequestId::from_bytes(&pus_tm.source_data()[0..RequestId::SIZE_AS_BYTES])
--- a/satrs/tests/tcp_servers.rs
+++ b/satrs/tests/tcp_servers.rs
@@ -17,12 +17,13 @@ use core::{
 use std::{
    io::{Read, Write},
    net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream},
-    sync::{mpsc, Mutex},
+    sync::{Mutex, mpsc},
    thread,
 };

 use hashbrown::HashSet;
 use satrs::{
+    ComponentId,
    encoding::{
        ccsds::{SpValidity, SpacePacketValidator},
        cobs::encode_packet_with_cobs,
@@ -32,11 +33,10 @@ use satrs::{
        TcpSpacepacketsServer, TcpTmtcInCobsServer,
    },
    tmtc::PacketSource,
-    ComponentId,
 };
 use spacepackets::{
-    ecss::{tc::PusTcCreator, WritablePusPacket},
    CcsdsPacket, PacketId, SpHeader,
+    ecss::{WritablePusPacket, tc::PusTcCreator},
 };
 use std::{collections::VecDeque, sync::Arc, vec::Vec};
Author	SHA1	Message	Date
Robin Mueller	e2fbc08545	continue updating embedded examples	2025-09-10 18:06:50 +02:00
Robin Müller	2e58a311c8	Merge pull request 'CI fix and naming improvement' (#249 ) from example-ci-fix into main Reviewed-on: #249	2025-09-06 19:40:17 +02:00
Robin Mueller	62d64e692a	CI fix and naming improvement	2025-09-06 19:36:56 +02:00
Robin Müller	3784f47b66	Merge pull request 'update heapless dependency' (#248 ) from update-deps into main Reviewed-on: #248	2025-09-06 19:32:18 +02:00
Robin Mueller	e1911f1b6e	update heapless dependency	2025-09-06 19:32:06 +02:00
Robin Müller	2e53ce1871	Merge pull request 'update trait names' (#247 ) from update-trait-names into main Reviewed-on: #247	2025-09-06 19:31:46 +02:00
Robin Mueller	a6c460129b	update trait names	2025-09-06 19:26:39 +02:00
Robin Müller	d5ecefd683	Merge pull request 'small changelog adaption' (#246 ) from small-changelog-adaption into main Reviewed-on: #246	2025-08-26 14:29:41 +02:00
Robin Mueller	2f9f3b8183	small changelog adaption	2025-08-26 14:28:22 +02:00
Robin Müller	b28cff85de	Merge pull request 'prepare next MIB release' (#245 ) from satrs-mib-release into main Reviewed-on: #245	2025-08-26 14:26:47 +02:00
Robin Mueller	da3de9f22c	prepare next MIB release	2025-08-26 14:24:48 +02:00
Robin Müller	aefdf0987d	Merge pull request 'add matrix chat badge' (#243 ) from add-chat-badge into main Reviewed-on: #243	2025-08-14 14:17:56 +02:00
Robin Mueller	7ae9e62d66	add matrix chat badge	2025-08-14 14:17:41 +02:00
Robin Müller	fea1a9028b	Merge pull request 'edition bump to 2024 ald clippy' (#244 ) from edition-bump-clippy-fixes into main Reviewed-on: #244	2025-08-14 14:17:18 +02:00
Robin Mueller	abc145fb2d	edition bump to 2024 ald clippy	2025-08-14 14:10:00 +02:00
Robin Müller	490635dfcf	Merge pull request 'prepare patch releases' (#242 ) from prep-patch-releases into main Reviewed-on: #242	2025-07-23 14:09:59 +02:00
Robin Mueller	de3d22a022	prepare patch releases	2025-07-23 14:05:04 +02:00
Robin Müller	cbe211fe8b	Merge pull request 'CFDP reference' (#241 ) from cfdp-ref into main Reviewed-on: #241	2025-07-22 10:47:08 +02:00
Robin Mueller	e379bc3fd7	CFDP	2025-07-22 10:46:56 +02:00
Robin Müller	a61ee85796	Merge pull request 'clippy fixes' (#240 ) from clippy-fixes into main Reviewed-on: #240	2025-07-22 10:44:42 +02:00
Robin Mueller	81473b30f9	clippy fixes	2025-07-22 10:44:11 +02:00
Robin Müller	22675a73f9	Merge pull request 'changelog' (#239 ) from satrs-changelog into main Reviewed-on: #239	2025-07-22 10:36:58 +02:00
Robin Mueller	c68e3d4f75	changelog	2025-07-22 10:35:38 +02:00
Robin Müller	3deedfba17	Merge pull request 'bump all dependencies' (#238 ) from dependency-update into main Reviewed-on: #238	2025-07-22 10:31:15 +02:00
Robin Mueller	533caea0fe	bump all dependencies	2025-07-22 10:29:54 +02:00
Robin Müller	848fe6f207	Merge pull request 'spacepackets update' (#237 ) from update-satrs-deps into main Reviewed-on: #237	2025-07-18 19:24:55 +02:00
Robin Mueller	cf64fea7d9	bump cobs-rs dependency	2025-07-18 19:24:40 +02:00
Robin Müller	4948db3fa5	Merge pull request 'bump cobs-rs dependency' (#236 ) from update-satrs-deps into main Reviewed-on: #236	2025-07-18 19:19:58 +02:00
Robin Mueller	1920e4878c	bump cobs-rs dependency	2025-07-18 19:19:24 +02:00
Robin Müller	f46bc94b04	Merge pull request 'some test fixes' (#235 ) from test-fix into main Reviewed-on: #235	2025-05-19 15:49:02 +02:00
Robin Mueller	fb45da1890	some test fixes	2025-05-19 15:46:57 +02:00
Robin Müller	f600ee499a	Merge pull request 'add first generator' (#234 ) from generators into main Reviewed-on: #234	2025-05-19 15:23:37 +02:00
Robin Mueller	3f28f60c59	add first generator	2025-05-19 15:21:51 +02:00
Robin Müller	44b1f2b037	Merge pull request 'possible fix for clippy warning' (#233 ) from possible-fix-for-clippy-warning into main Reviewed-on: #233	2025-05-19 15:15:24 +02:00
Robin Mueller	4b22958b34	possible fix for clippy warning	2025-05-19 15:14:59 +02:00
Robin Müller	a711c6acd9	Merge pull request 'bump spacepackets' (#232 ) from bump-spacepackets into main Reviewed-on: #232	2025-05-19 14:19:00 +02:00
Robin Mueller	99a954a1f5	some tweaks	2025-05-19 14:18:26 +02:00
Robin Mueller	4a4fd7ac2c	use git deps	2025-05-16 19:49:43 +02:00
Robin Mueller	9bf08849a2	annoying	2025-05-16 19:43:45 +02:00
Robin Müller	b8f7fefe26	Merge pull request 'should fix tests' (#231 ) from test-fix into main Reviewed-on: #231	2025-05-10 16:31:14 +02:00
Robin Mueller	a501832698	should fix tests	2025-05-10 16:30:37 +02:00
Robin Müller	c7284d3f1c	Merge pull request 'minor wording improvements' (#230 ) from some-wording-improvements into main Reviewed-on: #230	2025-05-10 16:27:37 +02:00
Robin Müller	18263d4568	Merge branch 'main' into some-wording-improvements	2025-05-10 16:27:29 +02:00
Robin Mueller	95519c1363	minor wording improvements	2025-05-10 16:27:04 +02:00
Robin Müller	2ec32717d0	Merge pull request 'use released dependencies' (#229 ) from use-relesed-dependencies into main Reviewed-on: #229	2025-05-10 16:24:37 +02:00
Robin Mueller	bfdd777685	use released dependencies	2025-05-10 16:24:06 +02:00
Robin Müller	b54c2b7863	Merge pull request 'spacepackets update' (#227 ) from spacepackets-update into main Reviewed-on: #227	2025-05-10 16:19:07 +02:00
Robin Müller	19f3355283	Merge pull request 'update SIM suite name' (#228 ) from update-sim-suite-name into main Reviewed-on: #228	2025-05-10 16:18:16 +02:00
Robin Mueller	4aeb28d2f1	update SIM suite name	2025-05-10 16:14:48 +02:00
Robin Mueller	ddc4544456	spacepackets update, clippy fixes	2025-05-10 16:13:45 +02:00
Robin Müller	9ab36c0362	Merge pull request 'update docs' (#226 ) from update-docs into main Reviewed-on: #226	2025-05-06 16:21:17 +02:00
Robin Müller	b95769c177	Merge branch 'main' into update-docs	2025-05-06 16:21:10 +02:00
Robin Müller	bb20533ae1	Merge pull request 'remove token API for verification creator core' (#224 ) from simplify-verification-reporter-core into main Reviewed-on: #224	2025-05-05 19:03:34 +02:00
Robin Mueller	27cacd0f43	remove token API for verification creator core	2025-05-05 19:02:37 +02:00
Robin Mueller	bd6488e87b	update docs	2025-04-01 20:58:18 +02:00
Robin Müller	52ec0d44aa	Merge pull request 'bump README links' (#223 ) from update-readme-links into main Reviewed-on: #223	2025-04-01 15:15:14 +02:00
Robin Mueller	4fa9f8d685	bump README links	2025-04-01 15:05:28 +02:00