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
77 changed files with 2468 additions and 1772 deletions
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@
 [![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
 =========
@@ -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-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;
--- 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);
--- 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(),
--- 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,7 +102,7 @@ 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);
        }
@@ -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>
    {
@@ -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>
    {
@@ -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>,
 }

@@ -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,7 @@ version = "1"
 optional = true

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

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

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

 [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,10 @@ 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
@@ -46,5 +50,6 @@ Allow `spacepackets` range starting with v0.10 and v0.11.

 Initial release.

-[unreleased]: https://egit.irs.uni-stuttgart.de/rust/sat-rs/compare/satrs-shared-v0.2.2...HEAD
+[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.2"
+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"
@@ -21,9 +22,6 @@ optional = true
 version = "1"
 optional = true

-[dependencies.spacepackets]
-version = "0.14"
-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,26 +13,27 @@ keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]

 [dependencies]
-satrs-shared = { version = ">=0.1.3, <=0.2", path = "../satrs-shared" }
+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"
 num_enum = { version = ">0.5, <=0.7", default-features = false }
-spacepackets = { version = "0.14", default-features = false }
-cobs = { version = "0.4", default-features = false, git = "https://github.com/jamesmunns/cobs.rs.git", branch = "main" }
+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
@@ -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);
 }
@@ -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;
--- a/satrs/src/executable.rs
+++ b/satrs/src/executable.rs
@@ -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).
@@ -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;
@@ -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.
@@ -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,
--- 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,13 +107,13 @@ 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
@@ -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)
        }
    }
@@ -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;
--- 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,
        >,
    }
--- 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];
@@ -971,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 {
@@ -1008,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,
@@ -1045,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) => {
@@ -1070,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(),
            }
        }
    }
@@ -1129,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>,
@@ -1137,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,
@@ -1261,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;
@@ -1288,7 +1290,7 @@ pub mod test_util {

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

@@ -1296,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::*;

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

@@ -1404,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]),
@@ -1487,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(
@@ -1501,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,
@@ -1530,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 {
--- a/satrs/src/pus/scheduler.rs
+++ b/satrs/src/pus/scheduler.rs
@@ -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,
    };
@@ -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();
--- 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,
        >,
--- 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,
        >,
    }
@@ -225,7 +224,7 @@ mod tests {
        handler: PusService17TestHandler<
            MpscTcReceiver,
            MpscTmAsVecSender,
-            EcssTcInVecConverter,
+            EcssTcVecCacher,
            VerificationReporter,
        >,
    }
--- 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);
@@ -81,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;
@@ -90,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;
@@ -102,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.
 ///
@@ -511,9 +511,7 @@ 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 read_request_id_from_tc(pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> RequestId {
+    pub fn read_request_id(&self, pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> RequestId {
        RequestId::new(pus_tc)
    }

@@ -846,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,
@@ -876,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);
    }

@@ -886,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) {}
    }

@@ -899,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,
@@ -919,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 {
@@ -943,7 +941,7 @@ pub mod alloc_mod {
                        + cfg.fail_code_field_width
                        + cfg.max_fail_data_len
                ]),
-                reporter_creator: reporter,
+                report_creator: reporter,
                tm_hook,
            }
        }
@@ -952,9 +950,7 @@ pub mod alloc_mod {
            &self,
            pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
        ) -> VerificationToken<TcStateNone> {
-            VerificationToken::<TcStateNone>::new(
-                VerificationReportCreator::read_request_id_from_tc(pus_tc),
-            )
+            VerificationToken::<TcStateNone>::new(self.report_creator.read_request_id(pus_tc))
        }

        pub fn start_verification_with_req_id(
@@ -965,7 +961,7 @@ pub mod alloc_mod {
        }

        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 dest_id(&self) -> u16;
@@ -978,11 +974,11 @@ 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;
            }
@@ -1008,7 +1004,7 @@ pub mod alloc_mod {
        ) -> Result<VerificationToken<TcStateAccepted>, EcssTmtcError> {
            let mut source_data_buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
+                .report_creator
                .acceptance_success(
                    source_data_buf.as_mut_slice(),
                    &token.request_id(),
@@ -1031,7 +1027,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
                .acceptance_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
@@ -1050,7 +1046,7 @@ pub mod alloc_mod {
        ) -> Result<VerificationToken<TcStateStarted>, EcssTmtcError> {
            let mut buf = self.source_data_buf.borrow_mut();
            let mut tm_creator = self
-                .reporter_creator
+                .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);
@@ -1070,7 +1066,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
                .start_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
@@ -1090,7 +1086,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_success(
                    buf.as_mut_slice(),
                    &token.request_id(),
@@ -1117,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);
@@ -1138,7 +1134,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
                .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);
@@ -1158,7 +1154,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
                .completion_failure(buf.as_mut_slice(), &token.request_id(), 0, 00, params)
                .map_err(PusError::ByteConversion)?;
            self.tm_hook.modify_tm(&mut tm_creator);
@@ -1686,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) {}
@@ -1787,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());
@@ -1795,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 {
--- 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)]
@@ -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_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;
--- 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