Merge remote-tracking branch 'origin/main' into more-smaller-fixes-embedded-example

2024-04-02 10:15:45 +02:00
parent 52a649d687 344fe6a4c0
commit 1fcc1b17aa
38 changed files with 39757 additions and 1210 deletions
@@ -8,12 +8,17 @@
 sat-rs
 =========

-This is the repository of the sat-rs framework. Its primary goal is to provide re-usable components
+This is the repository of the sat-rs library. Its primary goal is to provide re-usable components
 to write on-board software for remote systems like rovers or satellites. It is specifically written
 for the special requirements for these systems. You can find an overview of the project and the
 link to the [more high-level sat-rs book](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/)
 at the [IRS software projects website](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/).

+This is early-stage software. Important features are missing. New releases
+with breaking changes are released regularly, with all changes documented inside respective
+changelog files. You should only use this library if your are willing to work in this
+environment.
+
 A lot of the architecture and general design considerations are based on the
 [FSFW](https://egit.irs.uni-stuttgart.de/fsfw/fsfw) C++ framework which has flight heritage
 through the 2 missions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)
@@ -15,7 +15,7 @@ action commanding could look like.
 2. Target ID and Action String based. The target ID is the same as in the first proposal, but
   the unique action is identified by a string.

-The framework provides an `ActionRequest` abstraction to model both of these cases.
+The library provides an `ActionRequest` abstraction to model both of these cases.

 ## Commanding with ECSS PUS 8

@@ -20,7 +20,7 @@ components.
 1. [UDP TMTC Server](https://docs.rs/satrs/latest/satrs/hal/host/udp_server/index.html).
   UDP is already packet based which makes it an excellent fit for exchanging space packets.
 2. [TCP TMTC Server Components](https://docs.rs/satrs/latest/satrs/hal/std/tcp_server/index.html).
-   TCP is a stream based protocol, so the framework provides building blocks to parse telemetry
+   TCP is a stream based protocol, so the library provides building blocks to parse telemetry
   from an arbitrary bytestream. Two concrete implementations are provided:
    - [TCP spacepackets server](https://docs.rs/satrs/latest/satrs/hal/std/tcp_server/struct.TcpSpacepacketsServer.html)
      to parse tightly packed CCSDS Spacepackets.
@@ -1,13 +1,14 @@
-# Framework Design
+# Library Design

 Satellites and space systems in general are complex systems with a wide range of requirements for
-both the hardware and the software. Consequently, the general design of the framework is centered
+both the hardware and the software. Consequently, the general design of the library is centered
 around many light-weight components which try to impose as few restrictions as possible on how to
-solve certain problems.
+solve certain problems. This is also the reason why sat-rs is explicitely called a library
+instead of a framework.

 There are still a lot of common patterns and architectures across these systems where guidance
 of how to solve a problem and a common structure would still be extremely useful to avoid pitfalls
-which were already solved and to avoid boilerplate code. This framework tries to provide this
+which were already solved and to avoid boilerplate code. This library tries to provide this
 structure and guidance the following way:

 1. Providing this book which explains the architecture and design patterns in respect to common
@@ -18,7 +19,7 @@ structure and guidance the following way:
 3. Providing a good test suite. This includes both unittests and integration tests. The integration
   tests can also serve as smaller usage examples than the large `satrs-example` application.

-This framework has special support for standards used in the space industry. This especially
+This library has special support for standards used in the space industry. This especially
 includes standards provided by Consultative Committee for Space Data Systems (CCSDS) and European
 Cooperation for Space Standardization (ECSS). It does not enforce using any of those standards,
 but it is always recommended to use some sort of standard for interoperability.
@@ -30,10 +31,10 @@ Flying Laptop Project by the University of Stuttgart with Airbus Defence and Spa
 It has flight heritage through the 2 mssions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)
 and [EIVE](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/EIVE/).
 Therefore, a lot of the design concepts were ported more or less unchanged to the `sat-rs`
-framework.
+library.
 FLP is a medium-size small satellite with a higher budget and longer development time than EIVE,
 which allowed to build a highly reliable system while EIVE is a smaller 6U+ cubesat which had a
-shorter development cycle and was built using cheaper COTS components. This framework also tries
+shorter development cycle and was built using cheaper COTS components. This library also tries
 to accumulate the knowledge of developing the OBSW and operating the satellite for both these
 different systems and provide a solution for a wider range of small satellite systems.

@@ -1,6 +1,6 @@
 # sat-rs Example Application

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

-This book is the primary information resource for the [sat-rs framework](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
+This book is the primary information resource for the [sat-rs library](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
 in addition to the regular API documentation. It contains the following resources:

 1. Architecture informations and consideration which would exceeds the scope of the regular API.
@@ -12,10 +12,15 @@ in addition to the regular API documentation. It contains the following resource

 # Introduction

-The primary goal of the sat-rs framework is to provide re-usable components
+The primary goal of the sat-rs library is to provide re-usable components
 to write on-board software for remote systems like rovers or satellites. It is specifically written
 for the special requirements for these systems.

+It should be noted that sat-rs is early-stage software. Important features are missing. New releases
+with breaking changes are released regularly, with all changes documented inside respective
+changelog files. You should only use this library if your are willing to work in this
+environment.
+
 A lot of the architecture and general design considerations are based on the
 [FSFW](https://egit.irs.uni-stuttgart.de/fsfw/fsfw) C++ framework which has flight heritage
 through the 2 missions [FLP](https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/smallsatelliteprogram/flying-laptop/)
@@ -5,11 +5,17 @@
 # runner = "arm-none-eabi-gdb -q -x openocd.gdb"
 # runner = "gdb-multiarch -q -x openocd.gdb"
 # runner = "gdb -q -x openocd.gdb"
-# runner = "probe-run --chip STM32F303VCTx --connect-under-reset"
+runner = "probe-rs run --chip STM32F303VCTx"

 rustflags = [
+  "-C", "linker=flip-link",
  # LLD (shipped with the Rust toolchain) is used as the default linker
  "-C", "link-arg=-Tlink.x",
+  "-C", "link-arg=-Tdefmt.x",
+
+  # This is needed if your flash or ram addresses are not aligned to 0x10000 in memory.x
+  # See https://github.com/rust-embedded/cortex-m-quickstart/pull/95
+  "-C", "link-arg=--nmagic",

  # if you run into problems with LLD switch to the GNU linker by commenting out
  # this line
@@ -26,3 +32,6 @@ rustflags = [
 [build]
 # comment out the following line if you intend to run unit tests on host machine
 target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
+
+[env]
+DEFMT_LOG = "info"
@@ -22,9 +22,9 @@ dependencies = [

 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"

 [[package]]
 name = "bare-metal"
@@ -60,7 +60,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40ac3d0c0a542d0ab5521211f873f62706a7136df415676f676d347e5a41dd80"
 dependencies = [
 "bitflags",
- "embedded-hal",
+ "embedded-hal 0.2.7",
 "nb 1.1.0",
 "vcell",
 ]
@@ -88,9 +88,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "chrono"
-version = "0.4.35"
+version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eaf5903dcbc0a39312feb77df2ff4c76387d591b9fc7b04a238dcf8bb62639a"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
 "num-traits",
 ]
@@ -114,7 +114,8 @@ checksum = "8ec610d8f49840a5b376c69663b6369e71f4b34484b9b2eb29fb918d92516cb9"
 dependencies = [
 "bare-metal 0.2.5",
 "bitfield",
- "embedded-hal",
+ "critical-section",
+ "embedded-hal 0.2.7",
 "volatile-register",
 ]

@@ -139,31 +140,12 @@ dependencies = [
 ]

 [[package]]
-name = "cortex-m-rtic"
-version = "1.1.4"
+name = "cortex-m-semihosting"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d696ae7390bdb9f7978f71ca7144256a2c4616240a6df9002da3c451f9fc8f02"
+checksum = "c23234600452033cc77e4b761e740e02d2c4168e11dbf36ab14a0f58973592b0"
 dependencies = [
- "bare-metal 1.0.0",
 "cortex-m",
- "cortex-m-rtic-macros",
- "heapless 0.7.17",
- "rtic-core",
- "rtic-monotonic",
- "version_check",
-]
-
-[[package]]
-name = "cortex-m-rtic-macros"
-version = "1.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eefb40b1ca901c759d29526e5c8a0a1b246c20caaa5b4cc5d0f0b94debecd4c7"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "rtic-syntax",
- "syn 1.0.109",
 ]

 [[package]]
@@ -207,7 +189,7 @@ dependencies = [
 "ident_case",
 "proc-macro2",
 "quote",
- "syn 2.0.53",
+ "syn 2.0.57",
 ]

 [[package]]
@@ -218,7 +200,72 @@ checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
 dependencies = [
 "darling_core",
 "quote",
- "syn 2.0.53",
+ "syn 2.0.57",
+]
+
+[[package]]
+name = "defmt"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3939552907426de152b3c2c6f51ed53f98f448babd26f28694c95f5906194595"
+dependencies = [
+ "bitflags",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-brtt"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2f0ac3635d0c89d12b8101fcb44a7625f5f030a1c0491124b74467eb5a58a78"
+dependencies = [
+ "critical-section",
+ "defmt",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18bdc7a7b92ac413e19e95240e75d3a73a8d8e78aa24a594c22cbb4d44b4bbda"
+dependencies = [
+ "defmt-parser",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.57",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff4a5fefe330e8d7f31b16a318f9ce81000d8e35e69b93eae154d16d2278f70f"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "defmt-test"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290966e8c38f94b11884877242de876280d0eab934900e9642d58868e77c5df1"
+dependencies = [
+ "cortex-m-rt",
+ "cortex-m-semihosting",
+ "defmt",
+ "defmt-test-macros",
+]
+
+[[package]]
+name = "defmt-test-macros"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "984bc6eca246389726ac2826acc2488ca0fe5fcd6b8d9b48797021951d76a125"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.57",
 ]

 [[package]]
@@ -251,6 +298,12 @@ dependencies = [
 "void",
 ]

+[[package]]
+name = "embedded-hal"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "361a90feb7004eca4019fb28352a9465666b24f840f5c3cddf0ff13920590b89"
+
 [[package]]
 name = "embedded-time"
 version = "0.12.1"
@@ -278,9 +331,15 @@ dependencies = [
 "darling",
 "proc-macro2",
 "quote",
- "syn 2.0.53",
+ "syn 2.0.57",
 ]

+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -296,6 +355,30 @@ dependencies = [
 "gcd",
 ]

+[[package]]
+name = "futures-core"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+
+[[package]]
+name = "futures-task"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+
+[[package]]
+name = "futures-util"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+]
+
 [[package]]
 name = "gcd"
 version = "2.3.0"
@@ -321,15 +404,6 @@ dependencies = [
 "version_check",
 ]

-[[package]]
-name = "hash32"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -341,22 +415,9 @@ dependencies = [

 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "heapless"
-version = "0.7.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
-dependencies = [
- "atomic-polyfill",
- "hash32 0.2.1",
- "rustc_version 0.4.0",
- "spin",
- "stable_deref_trait",
-]
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"

 [[package]]
 name = "heapless"
@@ -364,7 +425,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
 dependencies = [
- "hash32 0.3.1",
+ "hash32",
 "stable_deref_trait",
 ]

@@ -376,39 +437,14 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

 [[package]]
 name = "indexmap"
-version = "1.9.3"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
- "autocfg",
+ "equivalent",
 "hashbrown",
 ]

-[[package]]
-name = "itm_logger"
-version = "0.1.3-alpha.0"
-source = "git+https://github.com/robamu/itm_logger.rs.git?branch=all_features#83ee7a6c57f525a70d0cc5bb7e65826d0ce938a0"
-dependencies = [
- "cortex-m",
- "log",
-]
-
-[[package]]
-name = "lock_api"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
-
 [[package]]
 name = "lsm303dlhc"
 version = "0.2.0"
@@ -416,7 +452,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5d1a5c290951321d1b0d4a40edd828537de9889134a0e67c5146542ae57706"
 dependencies = [
 "cast",
- "embedded-hal",
+ "embedded-hal 0.2.7",
 "generic-array 0.11.2",
 ]

@@ -523,16 +559,17 @@ checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.53",
+ "syn 2.0.57",
 ]

 [[package]]
-name = "panic-itm"
-version = "0.4.2"
+name = "panic-probe"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d577d97d1b31268087b6dddf2470e6794ef5eee87d9dca7fcd0481695391a4c"
+checksum = "aa6fa5645ef5a760cd340eaa92af9c1ce131c8c09e7f8926d8a24b59d26652b9"
 dependencies = [
 "cortex-m",
+ "defmt",
 ]

 [[package]]
@@ -541,6 +578,18 @@ version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"

+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -585,13 +634,36 @@ dependencies = [

 [[package]]
 name = "rtcc"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fbd0d5bed2b76e27a7ef872568b34072c1af94c277cd52c17a89d54673b3fe"
+checksum = "95973c3a0274adc4f3c5b70d2b5b85618d6de9559a6737d3293ecae9a2fc0839"
 dependencies = [
 "chrono",
 ]

+[[package]]
+name = "rtic"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c443db16326376bdd64377da268f6616d5f804aba8ce799bac7d1f7f244e9d51"
+dependencies = [
+ "atomic-polyfill",
+ "bare-metal 1.0.0",
+ "cortex-m",
+ "critical-section",
+ "rtic-core",
+ "rtic-macros",
+]
+
+[[package]]
+name = "rtic-common"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0786b50b81ef9d2a944a000f60405bb28bf30cd45da2d182f3fe636b2321f35c"
+dependencies = [
+ "critical-section",
+]
+
 [[package]]
 name = "rtic-core"
 version = "1.0.0"
@@ -599,21 +671,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9369355b04d06a3780ec0f51ea2d225624db777acbc60abd8ca4832da5c1a42"

 [[package]]
-name = "rtic-monotonic"
-version = "1.0.0"
+name = "rtic-macros"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb8b0b822d1a366470b9cea83a1d4e788392db763539dc4ba022bcc787fece82"
-
-[[package]]
-name = "rtic-syntax"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f5e215601dc467752c2bddc6284a622c6f3d2bab569d992adcd5ab7e4cb9478"
+checksum = "54053598ea24b1b74937724e366558412a1777eb2680b91ef646db540982789a"
 dependencies = [
 "indexmap",
+ "proc-macro-error",
 "proc-macro2",
 "quote",
- "syn 1.0.109",
+ "syn 2.0.57",
+]
+
+[[package]]
+name = "rtic-monotonics"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058c2397dbd5bb4c5650a0e368c3920953e458805ff5097a0511b8147b3619d7"
+dependencies = [
+ "atomic-polyfill",
+ "cfg-if",
+ "cortex-m",
+ "embedded-hal 1.0.0",
+ "fugit",
+ "rtic-time",
+]
+
+[[package]]
+name = "rtic-time"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b232e7aebc045cfea81cdd164bc2727a10aca9a4568d406d0a5661cdfd0f19"
+dependencies = [
+ "critical-section",
+ "futures-util",
+ "rtic-common",
 ]

 [[package]]
@@ -658,16 +750,19 @@ dependencies = [
 "cobs 0.2.3 (git+https://github.com/robamu/cobs.rs.git?branch=all_features)",
 "cortex-m",
 "cortex-m-rt",
- "cortex-m-rtic",
- "embedded-hal",
+ "cortex-m-semihosting",
+ "defmt",
+ "defmt-brtt",
+ "defmt-test",
+ "embedded-hal 0.2.7",
 "enumset",
- "heapless 0.8.0",
- "itm_logger",
- "panic-itm",
+ "heapless",
+ "panic-probe",
+ "rtic",
+ "rtic-monotonics",
 "satrs",
 "stm32f3-discovery",
 "stm32f3xx-hal",
- "systick-monotonic",
 ]

 [[package]]
@@ -679,12 +774,6 @@ dependencies = [
 "spacepackets",
 ]

-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
 [[package]]
 name = "semver"
 version = "0.9.0"
@@ -732,15 +821,6 @@ dependencies = [
 "zerocopy",
 ]

-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api",
-]
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -786,7 +866,7 @@ dependencies = [
 [[package]]
 name = "stm32f3xx-hal"
 version = "0.11.0-alpha.0"
-source = "git+https://github.com/robamu/stm32f3xx-hal?branch=complete-dma-update#f3c3b81b91ecd9498eb133f2cda0b061ce9c9d98"
+source = "git+https://github.com/robamu/stm32f3xx-hal?branch=complete-dma-update#04fc76b7912649c84b57bd0ab803ea3ccf2aadae"
 dependencies = [
 "bxcan",
 "cfg-if",
@@ -794,7 +874,7 @@ dependencies = [
 "cortex-m-rt",
 "critical-section",
 "embedded-dma",
- "embedded-hal",
+ "embedded-hal 0.2.7",
 "embedded-time",
 "enumset",
 "nb 1.1.0",
@@ -813,7 +893,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90a4adc8cbd1726249b161898e48e0f3f1ce74d34dc784cbbc98fba4ed283fbf"
 dependencies = [
- "embedded-hal",
+ "embedded-hal 0.2.7",
 ]

 [[package]]
@@ -829,9 +909,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.53"
+version = "2.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7383cd0e49fff4b6b90ca5670bfd3e9d6a733b3f90c686605aa7eec8c4996032"
+checksum = "11a6ae1e52eb25aab8f3fb9fca13be982a373b8f1157ca14b897a825ba4a2d35"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -839,14 +919,23 @@ dependencies = [
 ]

 [[package]]
-name = "systick-monotonic"
-version = "1.0.1"
+name = "thiserror"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67fb822d5c615a0ae3a4795ee5b1d06381c7faf488d861c0a4fa8e6a88d5ff84"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
 dependencies = [
- "cortex-m",
- "fugit",
- "rtic-monotonic",
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.57",
 ]

 [[package]]
@@ -912,5 +1001,5 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.53",
+ "syn 2.0.57",
 ]
@@ -2,31 +2,34 @@
 name = "satrs-example-stm32f3-disco"
 version = "0.1.0"
 edition = "2021"
+default-run = "satrs-example-stm32f3-disco"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cortex-m = "0.7"
+cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7"
-embedded-hal = "0.2.6"
-cortex-m-rtic = "1.0"
-enumset = "1.0"
+defmt = "0.3"
+defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
+panic-probe = { version = "0.3", features = ["print-defmt"] }
+embedded-hal = "0.2.7"
+cortex-m-semihosting = "0.5.0"
+enumset = "1"
 heapless = "0.8"
-systick-monotonic = "1.0"
+
+[dependencies.rtic]
+version = "2"
+features = ["thumbv7-backend"]
+
+[dependencies.rtic-monotonics]
+version = "1"
+features = ["cortex-m-systick"]

 [dependencies.cobs]
 git = "https://github.com/robamu/cobs.rs.git"
 branch = "all_features"
 default-features = false

-[dependencies.panic-itm]
-version = "0.4"
-
-[dependencies.itm_logger]
-git = "https://github.com/robamu/itm_logger.rs.git"
-branch = "all_features"
-version = "0.1.3-alpha.0"
-
 [dependencies.stm32f3xx-hal]
 git = "https://github.com/robamu/stm32f3xx-hal"
 version = "0.11.0-alpha.0"
@@ -43,17 +46,37 @@ branch = "complete-dma-update-hal"
 # path = "../stm32f3-discovery"

 [dependencies.satrs]
-# git = "https://egit.irs.uni-stuttgart.de/rust/satrs-core.git"
 version = "0.2.0-rc.0"
 default-features = false

-# this lets you use `cargo fix`!
-# [[bin]]
-# name = "stm32f3-blinky"
-# test = false
-# bench = false
+[dev-dependencies]
+defmt-test = "0.3"

+# cargo test
+[profile.test]
+codegen-units = 1
+debug = 2
+debug-assertions = true # <-
+incremental = false
+opt-level = "s" # <-
+overflow-checks = true # <-
+
+# cargo build/run --release
 [profile.release]
-codegen-units = 1 # better optimizations
-debug = true # symbols are nice and they don't increase the size on Flash
-lto = true # better optimizations
+codegen-units = 1
+debug = 2
+debug-assertions = false # <-
+incremental = false
+lto = 'fat'
+opt-level = "s" # <-
+overflow-checks = false # <-
+
+# cargo test --release
+[profile.bench]
+codegen-units = 1
+debug = 2
+debug-assertions = false # <-
+incremental = false
+lto = 'fat'
+opt-level = "s" # <-
+overflow-checks = false # <-
@@ -2,26 +2,24 @@ sat-rs example for the STM32F3-Discovery board
 =======

 This example application shows how the [sat-rs framework](https://egit.irs.uni-stuttgart.de/rust/satrs-launchpad)
-can be used on an embedded target. It also shows how a relatively simple OBSW could be built when no
-standard runtime is available. It uses [RTIC](https://rtic.rs/1/book/en/) as the concurrency
-framework.
+can be used on an embedded target.
+It also shows how a relatively simple OBSW could be built when no standard runtime is available.
+It uses [RTIC](https://rtic.rs/1/book/en/) as the concurrency framework and the
+[defmt](https://defmt.ferrous-systems.com/) framework for logging.

 The STM32F3-Discovery device was picked because it is a cheap Cortex-M4 based device which is also
 used by the [Rust Embedded Book](https://docs.rust-embedded.org/book/intro/hardware.html) and the
 [Rust Discovery](https://docs.rust-embedded.org/discovery/f3discovery/) book as an introduction
 to embedded Rust.

-If you would like to access the ITM log output, you need to connect the PB3 pin to the CN3 pin
-of the SWD header like [shown here](https://docs.rust-embedded.org/discovery/f3discovery/06-hello-world/index.html).
-
 ## Pre-Requisites

 Make sure the following tools are installed:

-1. `openocd`: This is the debug server used to debug the STM32F3. You can install this from
-   [`xPacks`](https://xpack.github.io/dev-tools/openocd/install/). You can also use the one provided
-   by a STM32Cube installation.
-2. A debugger like `arm-none-eabi-gdb` or `gdb-multiarch`.
+1. [`probe-rs`](https://probe.rs/): Application used to flash and debug the MCU.
+2. Optional and recommended: [VS Code](https://code.visualstudio.com/) with
+   [probe-rs plugin](https://marketplace.visualstudio.com/items?itemName=probe-rs.probe-rs-debugger)
+   for debugging.

 ## Preparing Rust and the repository

@@ -52,23 +50,19 @@ you can simply build the application with
 cargo build
 ```

-## Flashing and Debugging from the command line
+## Flashing from the command line

-Make sure you have `openocd` and `itmdump` installed first.
+You can flash the application from the command line using `probe-rs`:

-1. Configure a runner inside your `.cargo/config.toml` file by uncommenting an appropriate line
-   depending on the application you want to use for debugging
-2. Start `openocd` inside the project folder. This will start `openocd` with the provided
-   `openocd.cfg` configuration file.
-3. Use `cargo run` to flash and debug the application in your terminal
-4. Use  `itmdump -F -f itm.txt` to print the logs received from the STM32F3 device. Please note
-   that the PB3 and CN3 pin of the SWD header need to be connected for this to work.
+```sh
+probe-rs run --chip STM32F303VCTx
+```

 ## Debugging with VS Code

 The STM32F3-Discovery comes with an on-board ST-Link so all that is required to flash and debug
-the board is a Mini-USB cable. The code in this repository was debugged using `openocd`
-and the VS Code [`Cortex-Debug` plugin](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug).
+the board is a Mini-USB cable. The code in this repository was debugged using [`probe-rs`](https://probe.rs/docs/tools/debuggerA)
+and the VS Code [`probe-rs` plugin](https://marketplace.visualstudio.com/items?itemName=probe-rs.probe-rs-debugger).
 Make sure to install this plugin first.

 Sample configuration files are provided inside the `vscode` folder.
@@ -80,19 +74,11 @@ to automatically rebuild and flash your application.
 The `tasks.json` and `launch.json` files are generic and you can use them immediately by opening
 the folder in VS code or adding it to a workspace.

-If you would like to use a custom GDB application, you can specify the gdb binary in the following
-configuration variables in your `settings.json`:
-
- `"cortex-debug.gdbPath"`
- `"cortex-debug.gdbPath.linux"`
- `"cortex-debug.gdbPath.windows"`
- `"cortex-debug.gdbPath.osx"`
-
 ## Commanding with Python

 When the SW is running on the Discovery board, you can command the MCU via a serial interface,
 using COBS encoded PUS packets.
- 
+
 It is recommended to use a virtual environment to do this. To set up one in the command line,
 you can use `python3 -m venv venv` on Unix systems or `py -m venv venv` on Windows systems.
 After doing this, you can check the [venv tutorial](https://docs.python.org/3/tutorial/venv.html)
@@ -111,3 +97,9 @@ A default configuration file for the python application is provided and can be u
 ```sh
 cp def_tmtc_conf.json tmtc_conf.json
 ```
+
+After that, you can for example send a ping to the MCU using the following command
+
+```sh
+./main.py -p /ping
+```
@@ -1,18 +0,0 @@
-use std::env;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-
-fn main() {
-    // Put the linker script somewhere the linker can find it
-    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    File::create(out.join("memory.x"))
-        .unwrap()
-        .write_all(include_bytes!("memory.x"))
-        .unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-
-    // Only re-run the build script when memory.x is changed,
-    // instead of when any part of the source code changes.
-    println!("cargo:rerun-if-changed=memory.x");
-}
@@ -26,7 +26,7 @@ break main
 # # 8000000 must match the core clock frequency
 # # 2000000 is the frequency of the SWO pin. This was added for newer
 # openocd versions like v0.12.0.
-monitor tpiu config internal itm.txt uart off 8000000 2000000
+# monitor tpiu config internal itm.txt uart off 8000000 2000000

 # # OR: make the microcontroller SWO pin output compatible with UART (8N1)
 # # 8000000 must match the core clock frequency
@@ -34,7 +34,7 @@ monitor tpiu config internal itm.txt uart off 8000000 2000000
 # monitor tpiu config external uart off 8000000 2000000

 # # enable ITM port 0
-monitor itm port 0 on
+# monitor itm port 0 on

 load

@@ -1,17 +1,15 @@
 #![no_std]
 #![no_main]
+use satrs_example_stm32f3_disco as _;

-extern crate panic_itm;
-
-use cortex_m_rt::entry;
-
+use stm32f3_discovery::leds::Leds;
 use stm32f3_discovery::stm32f3xx_hal::delay::Delay;
 use stm32f3_discovery::stm32f3xx_hal::{pac, prelude::*};
-use stm32f3_discovery::leds::Leds;
 use stm32f3_discovery::switch_hal::{OutputSwitch, ToggleableOutputSwitch};

-#[entry]
-fn main()-> ! {
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    defmt::println!("STM32F3 Discovery Blinky");
    let dp = pac::Peripherals::take().unwrap();
    let mut rcc = dp.RCC.constrain();
    let cp = cortex_m::Peripherals::take().unwrap();
@@ -30,49 +28,49 @@ fn main()-> ! {
        gpioe.pe14,
        gpioe.pe15,
        &mut gpioe.moder,
-        &mut gpioe.otyper
+        &mut gpioe.otyper,
    );
    let delay_ms = 200u16;
    loop {
-        leds.ld3.toggle().ok();
+        leds.ld3_n.toggle().ok();
        delay.delay_ms(delay_ms);
-        leds.ld3.toggle().ok();
+        leds.ld3_n.toggle().ok();
        delay.delay_ms(delay_ms);

        //explicit on/off
-        leds.ld4.on().ok();
+        leds.ld4_nw.on().ok();
        delay.delay_ms(delay_ms);
-        leds.ld4.off().ok();
+        leds.ld4_nw.off().ok();
        delay.delay_ms(delay_ms);

-        leds.ld5.on().ok();
+        leds.ld5_ne.on().ok();
        delay.delay_ms(delay_ms);
-        leds.ld5.off().ok();
+        leds.ld5_ne.off().ok();
        delay.delay_ms(delay_ms);

-        leds.ld6.on().ok();
+        leds.ld6_w.on().ok();
        delay.delay_ms(delay_ms);
-        leds.ld6.off().ok();
-        delay.delay_ms(delay_ms);
-        
-        leds.ld7.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld7.off().ok();
-        delay.delay_ms(delay_ms);
-        
-        leds.ld8.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld8.off().ok();
-        delay.delay_ms(delay_ms);
-        
-        leds.ld9.on().ok();
-        delay.delay_ms(delay_ms);
-        leds.ld9.off().ok();
+        leds.ld6_w.off().ok();
        delay.delay_ms(delay_ms);

-        leds.ld10.on().ok();
+        leds.ld7_e.on().ok();
        delay.delay_ms(delay_ms);
-        leds.ld10.off().ok();
+        leds.ld7_e.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld8_sw.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld8_sw.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld9_se.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld9_se.off().ok();
+        delay.delay_ms(delay_ms);
+
+        leds.ld10_s.on().ok();
+        delay.delay_ms(delay_ms);
+        leds.ld10_s.off().ok();
        delay.delay_ms(delay_ms);
    }
 }
@@ -0,0 +1,51 @@
+#![no_main]
+#![no_std]
+
+use cortex_m_semihosting::debug;
+
+use defmt_brtt as _; // global logger
+
+use stm32f3xx_hal as _; // memory layout
+
+use panic_probe as _;
+
+// same panicking *behavior* as `panic-probe` but doesn't print a panic message
+// this prevents the panic message being printed *twice* when `defmt::panic` is invoked
+#[defmt::panic_handler]
+fn panic() -> ! {
+    cortex_m::asm::udf()
+}
+
+/// Terminates the application and makes a semihosting-capable debug tool exit
+/// with status code 0.
+pub fn exit() -> ! {
+    loop {
+        debug::exit(debug::EXIT_SUCCESS);
+    }
+}
+
+/// Hardfault handler.
+///
+/// Terminates the application and makes a semihosting-capable debug tool exit
+/// with an error. This seems better than the default, which is to spin in a
+/// loop.
+#[cortex_m_rt::exception]
+unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
+    loop {
+        debug::exit(debug::EXIT_FAILURE);
+    }
+}
+
+// defmt-test 0.3.0 has the limitation that this `#[tests]` attribute can only be used
+// once within a crate. the module can be in any file but there can only be at most
+// one `#[tests]` module in this library crate
+#[cfg(test)]
+#[defmt_test::tests]
+mod unit_tests {
+    use defmt::assert;
+
+    #[test]
+    fn it_works() {
+        assert!(true)
+    }
+}
@@ -1,12 +1,14 @@
 #![no_std]
 #![no_main]
-extern crate panic_itm;
+// global logger + panicking-behavior + memory layout
+use satrs_example_stm32f3_disco as _;

 use rtic::app;

 use heapless::{mpmc::Q8, Vec};
 #[allow(unused_imports)]
-use itm_logger::{debug, info, logger_init, warn};
+use rtic_monotonics::systick::fugit::TimerInstantU32;
+use rtic_monotonics::systick::ExtU32;
 use satrs::seq_count::SequenceCountProviderCore;
 use satrs::{
    pool::StoreError,
@@ -17,19 +19,18 @@ use stm32f3xx_hal::dma::dma1;
 use stm32f3xx_hal::gpio::{PushPull, AF7, PA2, PA3};
 use stm32f3xx_hal::pac::USART2;
 use stm32f3xx_hal::serial::{Rx, RxEvent, Serial, SerialDmaRx, SerialDmaTx, Tx, TxEvent};
-use systick_monotonic::{fugit::Duration, Systick};

 const UART_BAUD: u32 = 115200;
-const BLINK_FREQ_MS: u64 = 1000;
-const TX_HANDLER_FREQ_MS: u64 = 20;
-const MIN_DELAY_BETWEEN_TX_PACKETS_MS: u16 = 5;
+const BLINK_FREQ_MS: u32 = 1000;
+const TX_HANDLER_FREQ_MS: u32 = 20;
+const MIN_DELAY_BETWEEN_TX_PACKETS_MS: u32 = 5;
 const MAX_TC_LEN: usize = 128;
 const MAX_TM_LEN: usize = 128;
 pub const PUS_APID: u16 = 0x02;

 type TxType = Tx<USART2, PA2<AF7<PushPull>>>;
 type RxType = Rx<USART2, PA3<AF7<PushPull>>>;
-type MsDuration = Duration<u64, 1, 1000>;
+type InstantFugit = TimerInstantU32<1000>;
 type TxDmaTransferType = SerialDmaTx<&'static [u8], dma1::C7, TxType>;
 type RxDmaTransferType = SerialDmaRx<&'static mut [u8], dma1::C6, RxType>;

@@ -53,9 +54,6 @@ type TcPacket = Vec<u8, MAX_TC_LEN>;

 static TM_REQUESTS: Q8<TmPacket> = Q8::new();

-const TC_POOL_SLOTS: usize = 8;
-const TM_POOL_SLOTS: usize = 8;
-
 use core::cell::RefCell;
 use core::sync::atomic::{AtomicU16, Ordering};

@@ -97,14 +95,12 @@ pub struct TxIdle {

 pub struct TmSender {
    vec: Option<RefCell<Vec<u8, MAX_TM_LEN>>>,
-    ctx: &'static str,
 }

 impl TmSender {
-    pub fn new(tm_packet: TmPacket, ctx: &'static str) -> Self {
+    pub fn new(tm_packet: TmPacket) -> Self {
        Self {
            vec: Some(RefCell::new(tm_packet)),
-            ctx,
        }
    }
 }
@@ -133,7 +129,12 @@ impl EcssTmSenderCore for TmSender {
                }
                vec.resize(tm.len_written(), 0).expect("vec resize failed");
                tm.write_to_bytes(vec.as_mut_slice())?;
-                info!(target: self.ctx, "Sending TM[{},{}] with size {}", tm.service(), tm.subservice(), tm.len_written());
+                defmt::info!(
+                    "Sending TM[{},{}] with size {}",
+                    tm.service(),
+                    tm.subservice(),
+                    tm.len_written()
+                );
                drop(vec);
                TM_REQUESTS
                    .enqueue(vec_ref.take())
@@ -151,11 +152,17 @@ pub enum UartTxState {
    Transmitting(Option<TxDmaTransferType>),
 }

-#[app(device = stm32f3xx_hal::pac, peripherals = true, dispatchers = [TIM20_BRK, TIM20_UP, TIM20_TRG_COM])]
+pub struct UartTxShared {
+    last_completed: Option<InstantFugit>,
+    state: UartTxState,
+}
+
+#[app(device = stm32f3xx_hal::pac, peripherals = true)]
 mod app {
    use super::*;
    use core::slice::Iter;
-    use cortex_m::iprintln;
+    use rtic_monotonics::systick::Systick;
+    use rtic_monotonics::Monotonic;
    use satrs::pus::verification::FailParams;
    use satrs::pus::verification::VerificationReporterCore;
    use satrs::spacepackets::{
@@ -166,15 +173,15 @@ mod app {
    use stm32f3_discovery::leds::Direction;
    use stm32f3_discovery::leds::Leds;
    use stm32f3xx_hal::prelude::*;
-    use stm32f3xx_hal::Switch;

    use stm32f3_discovery::switch_hal::OutputSwitch;
+    use stm32f3xx_hal::Switch;
    #[allow(dead_code)]
    type SerialType = Serial<USART2, (PA2<AF7<PushPull>>, PA3<AF7<PushPull>>)>;

    #[shared]
    struct Shared {
-        tx_transfer: UartTxState,
+        tx_shared: UartTxShared,
        rx_transfer: Option<RxDmaTransferType>,
    }

@@ -186,18 +193,14 @@ mod app {
        curr_dir: Iter<'static, Direction>,
    }

-    #[monotonic(binds = SysTick, default = true)]
-    type MonoTimer = Systick<1000>;
-
-    #[init(local = [
-        tc_pool_mem: [u8; TC_BUF_LEN * TC_POOL_SLOTS] = [0; TC_BUF_LEN * TC_POOL_SLOTS],
-        tm_pool_mem: [u8; MAX_TM_LEN * TM_POOL_SLOTS] = [0; MAX_TM_LEN * TM_POOL_SLOTS]
-    ])]
-    fn init(mut cx: init::Context) -> (Shared, Local, init::Monotonics) {
+    #[init]
+    fn init(cx: init::Context) -> (Shared, Local) {
        let mut rcc = cx.device.RCC.constrain();

-        let mono = Systick::new(cx.core.SYST, 8_000_000);
-        logger_init();
+        // Initialize the systick interrupt & obtain the token to prove that we did
+        let systick_mono_token = rtic_monotonics::create_systick_token!();
+        Systick::start(cx.core.SYST, 8_000_000, systick_mono_token);
+
        let mut flash = cx.device.FLASH.constrain();
        let clocks = rcc
            .cfgr
@@ -205,11 +208,11 @@ mod app {
            .sysclk(8.MHz())
            .pclk1(8.MHz())
            .freeze(&mut flash.acr);
-        // setup ITM output
-        iprintln!(
-            &mut cx.core.ITM.stim[0],
-            "Starting sat-rs demo application for the STM32F3-Discovery"
-        );
+
+        // Set up monotonic timer.
+        //let mono_timer = MonoTimer::new(cx.core.DWT, clocks, &mut cx.core.DCB);
+
+        defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery");
        let mut gpioe = cx.device.GPIOE.split(&mut rcc.ahb);

        let verif_reporter = VerificationReporterCore::new(PUS_APID).unwrap();
@@ -251,105 +254,133 @@ mod app {
        usart2.configure_tx_interrupt(TxEvent::TransmissionComplete, Switch::On);

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

        // This interrupt is immediately triggered, clear it. It will only be reset
        // by the hardware when data is received on RX (RXNE event)
        rx_serial.clear_event(RxEvent::Idle);
+        // For some reason, this is also immediately triggered..
+        tx_serial.clear_event(TxEvent::TransmissionComplete);
        let rx_transfer = rx_serial.read_exact(unsafe { DMA_RX_BUF.as_mut_slice() }, dma1.ch6);
-        info!(target: "init", "Spawning tasks");
+        defmt::info!("Spawning tasks");
        blink::spawn().unwrap();
        serial_tx_handler::spawn().unwrap();
        (
            Shared {
-                tx_transfer: UartTxState::Idle(Some(TxIdle {
-                    tx: tx_serial,
-                    dma_channel: dma1.ch7,
-                })),
+                tx_shared: UartTxShared {
+                    last_completed: None,
+                    state: UartTxState::Idle(Some(TxIdle {
+                        tx: tx_serial,
+                        dma_channel: dma1.ch7,
+                    })),
+                },
                rx_transfer: Some(rx_transfer),
            },
            Local {
+                //timer: mono_timer,
                leds,
                last_dir: Direction::North,
                curr_dir: Direction::iter(),
                verif_reporter,
            },
-            init::Monotonics(mono),
        )
    }

    #[task(local = [leds, curr_dir, last_dir])]
-    fn blink(cx: blink::Context) {
-        let toggle_leds = |dir: &Direction| {
-            let leds = cx.local.leds;
-            let last_led = leds.for_direction(*cx.local.last_dir);
+    async fn blink(cx: blink::Context) {
+        let blink::LocalResources {
+            leds,
+            curr_dir,
+            last_dir,
+            ..
+        } = cx.local;
+        let mut toggle_leds = |dir: &Direction| {
+            let last_led = leds.for_direction(*last_dir);
            last_led.off().ok();
            let led = leds.for_direction(*dir);
            led.on().ok();
-            *cx.local.last_dir = *dir;
+            *last_dir = *dir;
        };
-
-        match cx.local.curr_dir.next() {
-            Some(dir) => {
-                toggle_leds(dir);
-            }
-            None => {
-                *cx.local.curr_dir = Direction::iter();
-                toggle_leds(cx.local.curr_dir.next().unwrap());
+        loop {
+            match curr_dir.next() {
+                Some(dir) => {
+                    toggle_leds(dir);
+                }
+                None => {
+                    *curr_dir = Direction::iter();
+                    toggle_leds(curr_dir.next().unwrap());
+                }
            }
+            Systick::delay(BLINK_FREQ_MS.millis()).await;
        }
-        blink::spawn_after(MsDuration::from_ticks(BLINK_FREQ_MS)).unwrap();
    }

    #[task(
-        shared = [tx_transfer],
-        local = []
+        shared = [tx_shared],
    )]
-    fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
-        if let Some(vec) = TM_REQUESTS.dequeue() {
-            cx.shared.tx_transfer.lock(|tx_state| match tx_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_state = UartTxState::Transmitting(Some(transfer));
-                    // The memory block is automatically returned to the pool when it is dropped.
-                }
-                UartTxState::Transmitting(_) => {
-                    // This is a SW configuration error. Only the ISR which
-                    // detects transfer completion should be able to spawn a new
-                    // task, and that ISR should set the state to IDLE.
-                    panic!("invalid internal tx state detected")
-                }
-            })
-        } else {
-            cx.shared.tx_transfer.lock(|tx_state| {
-                if let UartTxState::Idle(_) = tx_state {
-                    serial_tx_handler::spawn_after(MsDuration::from_ticks(TX_HANDLER_FREQ_MS))
-                        .unwrap();
+    async fn serial_tx_handler(mut cx: serial_tx_handler::Context) {
+        loop {
+            let is_idle = cx.shared.tx_shared.lock(|tx_shared| {
+                if let UartTxState::Idle(_) = tx_shared.state {
+                    return true;
                }
+                false
            });
+            if is_idle {
+                let last_completed = cx.shared.tx_shared.lock(|shared| shared.last_completed);
+                if let Some(last_completed) = last_completed {
+                    let elapsed_ms = (Systick::now() - last_completed).to_millis();
+                    if elapsed_ms < MIN_DELAY_BETWEEN_TX_PACKETS_MS {
+                        Systick::delay((MIN_DELAY_BETWEEN_TX_PACKETS_MS - elapsed_ms).millis())
+                            .await;
+                    }
+                }
+            } else {
+                // Check for completion after 1 ms
+                Systick::delay(1.millis()).await;
+                continue;
+            }
+            if let Some(vec) = TM_REQUESTS.dequeue() {
+                cx.shared
+                    .tx_shared
+                    .lock(|tx_shared| match &mut tx_shared.state {
+                        UartTxState::Idle(tx) => {
+                            let encoded_len;
+                            //debug!(target: "serial_tx_handler", "bytes: {:x?}", &buf[0..len]);
+                            // Safety: We only copy the data into the TX DMA buffer in this task.
+                            // If the DMA is active, another branch will be taken.
+                            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
+                Systick::delay(1.millis()).await;
+                continue;
+            }
+            // Nothing to do, and we are idle.
+            Systick::delay(TX_HANDLER_FREQ_MS.millis()).await;
        }
    }

@@ -361,10 +392,13 @@ mod app {
            verif_reporter
        ],
    )]
-    fn serial_rx_handler(cx: serial_rx_handler::Context, received_packet: Vec<u8, MAX_TC_LEN>) {
-        let tgt: &'static str = "serial_rx_handler";
+    async fn serial_rx_handler(
+        cx: serial_rx_handler::Context,
+        received_packet: Vec<u8, MAX_TC_LEN>,
+    ) {
+        defmt::info!("running rx handler");
        cx.local.stamp_buf[0] = P_FIELD_BASE;
-        info!(target: tgt, "Received packet with {} bytes", received_packet.len());
+        defmt::info!("Received packet with {} bytes", received_packet.len());
        let decode_buf = cx.local.decode_buf;
        let packet = received_packet.as_slice();
        let mut start_idx = None;
@@ -375,16 +409,13 @@ mod app {
            }
        }
        if start_idx.is_none() {
-            warn!(
-                target: tgt,
-                "decoding error, can only process cobs encoded frames, data is all 0"
-            );
+            defmt::warn!("decoding error, can only process cobs encoded frames, data is all 0");
            return;
        }
        let start_idx = start_idx.unwrap();
        match cobs::decode(&received_packet.as_slice()[start_idx..], decode_buf) {
            Ok(len) => {
-                info!(target: tgt, "Decoded packet length: {}", len);
+                defmt::info!("Decoded packet length: {}", len);
                let pus_tc = PusTcReader::new(decode_buf);
                let verif_reporter = cx.local.verif_reporter;
                match pus_tc {
@@ -394,18 +425,15 @@ mod app {
                        verif_reporter,
                        cx.local.src_data_buf,
                        cx.local.stamp_buf,
-                        tgt,
                    ),
-                    Err(e) => {
-                        warn!(target: tgt, "Error unpacking PUS TC: {}", e);
+                    Err(_e) => {
+                        // TODO: Print error after API rework.
+                        defmt::warn!("Error unpacking PUS TC");
                    }
                }
            }
            Err(_) => {
-                warn!(
-                    target: tgt,
-                    "decoding error, can only process cobs encoded frames"
-                )
+                defmt::warn!("decoding error, can only process cobs encoded frames")
            }
        }
    }
@@ -416,10 +444,8 @@ mod app {
        verif_reporter: &mut VerificationReporterCore,
        src_data_buf: &mut [u8; MAX_TM_LEN],
        stamp_buf: &[u8; 7],
-        tgt: &'static str,
    ) {
-        info!(
-            target: tgt,
+        defmt::info!(
            "Found PUS TC [{},{}] with length {}",
            tc.service(),
            tc.subservice(),
@@ -428,7 +454,7 @@ mod app {

        let token = verif_reporter.add_tc(&tc);
        if tc.apid() != PUS_APID {
-            warn!(target: tgt, "Received tc with unknown APID {}", tc.apid());
+            defmt::warn!("Received tc with unknown APID {}", tc.apid());
            let sendable = verif_reporter
                .acceptance_failure(
                    src_data_buf,
@@ -438,10 +464,9 @@ mod app {
                    FailParams::new(stamp_buf, &EcssEnumU16::new(0), &[]),
                )
                .unwrap();
-            // let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-            let sender = TmSender::new(TmPacket::new(), tgt);
-            if let Err(e) = verif_reporter.send_acceptance_failure(sendable, &sender) {
-                warn!(target: tgt, "Sending acceptance failure failed: {:?}", e.0);
+            let sender = TmSender::new(TmPacket::new());
+            if let Err(_e) = verif_reporter.send_acceptance_failure(sendable, &sender) {
+                defmt::warn!("Sending acceptance failure failed");
            };
            return;
        }
@@ -449,12 +474,12 @@ mod app {
            .acceptance_success(src_data_buf, token, SEQ_COUNT_PROVIDER.get(), 0, stamp_buf)
            .unwrap();

-        // let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-        let sender = TmSender::new(TmPacket::new(), tgt);
+        let sender = TmSender::new(TmPacket::new());
        let accepted_token = match verif_reporter.send_acceptance_success(sendable, &sender) {
            Ok(token) => token,
-            Err(e) => {
-                warn!(target: "serial_rx_handler", "Sending acceptance success failed: {:?}", e.0);
+            Err(_e) => {
+                // TODO: Print error as soon as EcssTmtcError has Format attr.. or rework API.
+                defmt::warn!("Sending acceptance success failed");
                return;
            }
        };
@@ -471,18 +496,16 @@ mod app {
                    )
                    .unwrap();
                // let mem_block = poolmod::TM::alloc().unwrap().init([0u8; MAX_TM_LEN]);
-                let sender = TmSender::new(TmPacket::new(), tgt);
+                let sender = TmSender::new(TmPacket::new());
                let started_token = match verif_reporter.send_start_success(sendable, &sender) {
                    Ok(token) => token,
-                    Err(e) => {
-                        warn!(target: tgt, "Sending acceptance success failed: {:?}", e.0);
+                    Err(_e) => {
+                        // TODO: Print error as soon as EcssTmtcError has Format attr.. or rework API.
+                        defmt::warn!("Sending acceptance success failed");
                        return;
                    }
                };
-                info!(
-                    target: tgt,
-                    "Received PUS ping telecommand, sending ping reply TM[17,2]"
-                );
+                defmt::info!("Received PUS ping telecommand, sending ping reply TM[17,2]");
                let mut sp_header =
                    SpHeader::tc_unseg(PUS_APID, SEQ_COUNT_PROVIDER.get(), 0).unwrap();
                let sec_header = PusTmSecondaryHeader::new_simple(17, 2, stamp_buf);
@@ -493,7 +516,7 @@ mod app {
                    .expect("vec resize failed");
                ping_reply.write_to_bytes(&mut tm_packet).unwrap();
                if TM_REQUESTS.enqueue(tm_packet).is_err() {
-                    warn!(target: tgt, "TC queue full");
+                    defmt::warn!("TC queue full");
                    return;
                }
                SEQ_COUNT_PROVIDER.increment();
@@ -506,9 +529,9 @@ mod app {
                        stamp_buf,
                    )
                    .unwrap();
-                let sender = TmSender::new(TmPacket::new(), tgt);
-                if let Err(e) = verif_reporter.send_step_or_completion_success(sendable, &sender) {
-                    warn!(target: tgt, "Sending completion success failed: {:?}", e.0);
+                let sender = TmSender::new(TmPacket::new());
+                if let Err(_e) = verif_reporter.send_step_or_completion_success(sendable, &sender) {
+                    defmt::warn!("Sending completion success failed");
                }
            } else {
                // TODO: Invalid subservice
@@ -518,6 +541,7 @@ mod app {

    #[task(binds = DMA1_CH6, shared = [rx_transfer])]
    fn rx_dma_isr(mut cx: rx_dma_isr::Context) {
+        let mut tc_packet = TcPacket::new();
        cx.shared.rx_transfer.lock(|rx_transfer| {
            let rx_ref = rx_transfer.as_ref().unwrap();
            if rx_ref.is_complete() {
@@ -526,7 +550,6 @@ mod app {
                // The received data is transferred to another task now to avoid any processing overhead
                // during the interrupt. There are multiple ways to do this, we use a stack allocaed vector here
                // to do this.
-                let mut tc_packet = TcPacket::new();
                tc_packet.resize(buf.len(), 0).expect("vec resize failed");
                tc_packet.copy_from_slice(buf);

@@ -537,7 +560,7 @@ mod app {
                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler task failed");
                // If this happens, there is a high chance that the maximum packet length was
                // exceeded. Circular mode is not used here, so data might be missed.
-                warn!(
+                defmt::warn!(
                    "rx transfer with maximum length {}, might miss data",
                    TC_BUF_LEN
                );
@@ -545,23 +568,26 @@ mod app {
        });
    }

-    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_transfer])]
+    #[task(binds = USART2_EXTI26, shared = [rx_transfer, tx_shared])]
    fn serial_isr(mut cx: serial_isr::Context) {
-        cx.shared.tx_transfer.lock(|tx_state| match tx_state {
-            UartTxState::Idle(_) => (),
-            UartTxState::Transmitting(transfer) => {
-                let transfer_ref = transfer.as_ref().unwrap();
-                if transfer_ref.is_complete() {
-                    let transfer = transfer.take().unwrap();
-                    let (_, dma_channel, tx) = transfer.stop();
-                    *tx_state = UartTxState::Idle(Some(TxIdle { tx, dma_channel }));
-                    serial_tx_handler::spawn_after(MsDuration::from_ticks(
-                        MIN_DELAY_BETWEEN_TX_PACKETS_MS.into(),
-                    ))
-                    .unwrap();
+        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(Systick::now());
+                    }
                }
-            }
-        });
+            });
+        let mut tc_packet = TcPacket::new();
        cx.shared.rx_transfer.lock(|rx_transfer| {
            let rx_transfer_ref = rx_transfer.as_ref().unwrap();
            // Received a partial packet.
@@ -571,14 +597,12 @@ mod app {
                // 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.
-                let mut tc_packet = TcPacket::new();
                tc_packet
                    .resize(rx_len as usize, 0)
                    .expect("vec resize failed");
                tc_packet[0..rx_len as usize].copy_from_slice(&buf[0..rx_len as usize]);
                rx.clear_event(RxEvent::Idle);
-                // Only send owning pointer to pool memory and the received packet length.
-                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler task failed");
+                serial_rx_handler::spawn(tc_packet).expect("spawning rx handler failed");
                *rx_transfer = Some(rx.read_exact(buf, ch));
            }
        });
@@ -5,7 +5,7 @@
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
 		"rust-lang.rust",
-		"marus25.cortex-debug",
+		"probe-rs.probe-rs-debugger"
 	],
 	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
 	"unwantedRecommendations": []
@@ -1,66 +1,22 @@
 {
-    /* 
-     * Requires the Rust Language Server (RLS) and Cortex-Debug extensions
-     * https://marketplace.visualstudio.com/items?itemName=rust-lang.rust
-     * https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug
-     */
-    "version": "0.2.0",
-    "configurations": [
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "preLaunchTask": "${defaultBuildTask}",
+      "type": "probe-rs-debug",
+      "request": "launch",
+      "name": "probe-rs Debugging ",
+      "flashingConfig": {
+        "flashingEnabled": true
+      },
+      "chip": "STM32F303VCTx",
+      "coreConfigs": [
        {
-            /* Launches debug session for currently open example */
-            "type": "cortex-debug",
-            "request": "launch",
-            "name": "Debug",
-            "servertype": "openocd",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "cargo build",
-            "runToEntryPoint": "true",
-            "executable": "./target/thumbv7em-none-eabihf/debug/satrs-example-stm32f3-disco",
-            "preLaunchCommands": ["break rust_begin_unwind"],
-            "device": "STM32F303VCT6",
-            "configFiles": [
-                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
-                "interface/stlink.cfg",
-                "target/stm32f3x.cfg"
-            ],
-            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
-            "swoConfig": {
-                "enabled": true,
-                "cpuFrequency": 8000000,
-                "swoFrequency": 2000000,
-                "source": "probe",
-                "decoders": [
-                    { "type": "console", "label": "ITM", "port": 0 }
-                ]
-            }
-        },
-        {
-            /* Launches debug session for currently open example */
-            "type": "cortex-debug",
-            "request": "launch",
-            "name": "Release",
-            "servertype": "openocd",
-            "cwd": "${workspaceRoot}",
-            "preLaunchTask": "cargo build",
-            "runToEntryPoint": "true",
-            "executable": "./target/thumbv7em-none-eabihf/release/satrs-example-stm32f3-disco",
-            "preLaunchCommands": ["break rust_begin_unwind"],
-            "device": "STM32F303VCT6",
-            "configFiles": [
-                "${workspaceRoot}/.vscode/openocd-helpers.tcl",
-                "interface/stlink.cfg",
-                "target/stm32f3x.cfg"
-            ],
-            "svdFile": "${env:HOME}/.svd/STM32F303.svd",
-            "swoConfig": {
-                "enabled": true,
-                "cpuFrequency": 8000000,
-                "swoFrequency": 2000000,
-                "source": "probe",
-                "decoders": [
-                    { "type": "console", "label": "ITM", "port": 0 }
-                ]
-            }
+          "programBinary": "${workspaceFolder}/target/thumbv7em-none-eabihf/debug/satrs-example-stm32f3-disco",
+          "rttEnabled": true,
+          "svdFile": "STM32F303.svd"
        }
-    ]
-}
+      ]
+    }
+  ]
+}
@@ -25,7 +25,7 @@ path = "../satrs"

 [dependencies.satrs-mib]
 version = "0.1.1"
-# path = "../satrs-mib"
+path = "../satrs-mib"

 [features]
 dyn_tmtc = []
@@ -9,7 +9,7 @@ use satrs::{
    hk::HkRequest,
    spacepackets::{
        ecss::tm::{PusTmCreator, PusTmSecondaryHeader},
-        time::cds::{DaysLen16Bits, TimeProvider},
+        time::cds::{CdsTime, DaysLen16Bits},
        SequenceFlags, SpHeader,
    },
 };
@@ -23,7 +23,7 @@ use crate::{

 pub struct AcsTask<VerificationReporter: VerificationReportingProvider> {
    timestamp: [u8; 7],
-    time_provider: TimeProvider<DaysLen16Bits>,
+    time_provider: CdsTime<DaysLen16Bits>,
    verif_reporter: VerificationReporter,
    tm_sender: Box<dyn EcssTmSender>,
    request_rx: mpsc::Receiver<RequestWithToken>,
@@ -37,7 +37,7 @@ impl<VerificationReporter: VerificationReportingProvider> AcsTask<VerificationRe
    ) -> Self {
        Self {
            timestamp: [0; 7],
-            time_provider: TimeProvider::new_with_u16_days(0, 0),
+            time_provider: CdsTime::new_with_u16_days(0, 0),
            verif_reporter,
            tm_sender: Box::new(tm_sender),
            request_rx,
@@ -14,7 +14,7 @@ use satrs::{
        verification::{TcStateStarted, VerificationReportingProvider, VerificationToken},
        EcssTmSender,
    },
-    spacepackets::time::cds::{self, TimeProvider},
+    spacepackets::time::cds::{self, CdsTime},
 };
 use satrs_example::config::PUS_APID;

@@ -25,7 +25,7 @@ pub struct PusEventHandler<VerificationReporter: VerificationReportingProvider>
    pus_event_dispatcher: DefaultPusEventU32Dispatcher<()>,
    pus_event_man_rx: mpsc::Receiver<(EventU32, Option<Params>)>,
    tm_sender: Box<dyn EcssTmSender>,
-    time_provider: TimeProvider,
+    time_provider: CdsTime,
    timestamp: [u8; 7],
    verif_handler: VerificationReporter,
 }
@@ -57,7 +57,7 @@ impl<VerificationReporter: VerificationReportingProvider> PusEventHandler<Verifi
            event_request_rx,
            pus_event_dispatcher,
            pus_event_man_rx,
-            time_provider: cds::TimeProvider::new_with_u16_days(0, 0),
+            time_provider: cds::CdsTime::new_with_u16_days(0, 0),
            timestamp: [0; 7],
            verif_handler,
            tm_sender: Box::new(tm_sender),
@@ -45,7 +45,7 @@ use crate::udp::{StaticUdpTmHandler, UdpTmtcServer};
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
 use satrs::pus::{EcssTmSender, TmAsVecSenderWithId, TmInSharedPoolSenderWithId};
-use satrs::spacepackets::{time::cds::TimeProvider, time::TimeWriter};
+use satrs::spacepackets::{time::cds::CdsTime, time::TimeWriter};
 use satrs::tmtc::CcsdsDistributor;
 use satrs::ChannelId;
 use std::net::{IpAddr, SocketAddr};
@@ -513,7 +513,7 @@ fn main() {
    dyn_tmtc_pool_main();
 }

-pub fn update_time(time_provider: &mut TimeProvider, timestamp: &mut [u8]) {
+pub fn update_time(time_provider: &mut CdsTime, timestamp: &mut [u8]) {
    time_provider
        .update_from_now()
        .expect("Could not get current time");
@@ -6,7 +6,7 @@ use satrs::pus::{
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusServiceId;
-use satrs::spacepackets::time::cds::TimeProvider;
+use satrs::spacepackets::time::cds::CdsTime;
 use satrs::spacepackets::time::TimeWriter;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
 use std::sync::mpsc::Sender;
@@ -33,14 +33,14 @@ pub struct PusReceiver<VerificationReporter: VerificationReportingProvider> {
 }

 struct TimeStampHelper {
-    stamper: TimeProvider,
+    stamper: CdsTime,
    time_stamp: [u8; 7],
 }

 impl TimeStampHelper {
    pub fn new() -> Self {
        Self {
-            stamper: TimeProvider::new_with_u16_days(0, 0),
+            stamper: CdsTime::new_with_u16_days(0, 0),
            time_stamp: [0; 7],
        }
    }
@@ -14,7 +14,7 @@ use satrs::pus::{
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
-use satrs::spacepackets::time::cds::TimeProvider;
+use satrs::spacepackets::time::cds::CdsTime;
 use satrs::spacepackets::time::TimeWriter;
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
@@ -139,7 +139,7 @@ impl<
                        .tc_slice_raw(),
                )
                .unwrap();
-                let time_stamper = TimeProvider::from_now_with_u16_days().unwrap();
+                let time_stamper = CdsTime::now_with_u16_days().unwrap();
                let mut stamp_buf: [u8; 7] = [0; 7];
                time_stamper.write_to_bytes(&mut stamp_buf).unwrap();
                if subservice == 128 {
@@ -23,6 +23,7 @@ version = "1"
 optional = true

 [dependencies.satrs-shared]
+path = "../satrs-shared"
 version = "0.1.2"
 features = ["serde"]

@@ -26,7 +26,10 @@ features = ["full"]

 [dev-dependencies]
 trybuild = { version = "1", features = ["diff"] }
-satrs-shared = "0.1.2"
+
+[dev-dependencies.satrs-shared]
+version = "0.1.2"
+path = "../../satrs-shared"

 [dev-dependencies.satrs-mib]
 path = ".."
@@ -18,7 +18,9 @@ default-features = false
 optional = true

 [dependencies.spacepackets]
-version = "0.10"
+git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
+version = "0.11.0-rc.0"
+branch = "main"
 default-features = false

 [features]
@@ -17,7 +17,10 @@ delegate = ">0.7, <=0.10"
 paste = "1"
 smallvec = "1"
 crc = "3"
-satrs-shared = "0.1.2"
+
+[dependencies.satrs-shared]
+version = "0.1.2"
+path = "../satrs-shared"

 [dependencies.num_enum]
 version = ">0.5, <=0.7"
@@ -68,7 +71,9 @@ features = ["all"]
 optional = true

 [dependencies.spacepackets]
-version = "0.10"
+git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
+version = "0.11.0-rc.0"
+branch = "main"
 default-features = false

 [dependencies.cobs]
@@ -2,6 +2,7 @@ use crate::pus::{source_buffer_large_enough, EcssTmtcError};
 use spacepackets::ecss::tm::PusTmCreator;
 use spacepackets::ecss::tm::PusTmSecondaryHeader;
 use spacepackets::ecss::{EcssEnumeration, PusError};
+use spacepackets::ByteConversionError;
 use spacepackets::{SpHeader, MAX_APID};

 use crate::pus::EcssTmSenderCore;
@@ -9,145 +10,125 @@ use crate::pus::EcssTmSenderCore;
 pub use alloc_mod::EventReporter;
 pub use spacepackets::ecss::event::*;

-pub struct EventReporterBase {
-    msg_count: u16,
+pub struct EventReportCreator {
    apid: u16,
    pub dest_id: u16,
 }

-impl EventReporterBase {
+impl EventReportCreator {
    pub fn new(apid: u16) -> Option<Self> {
        if apid > MAX_APID {
            return None;
        }
        Some(Self {
-            msg_count: 0,
+            // msg_count: 0,
            dest_id: 0,
            apid,
        })
    }

-    pub fn event_info(
+    pub fn event_info<'time, 'src_data>(
        &mut self,
-        buf: &mut [u8],
-        sender: &mut (impl EcssTmSenderCore + ?Sized),
-        time_stamp: &[u8],
+        src_data_buf: &'src_data mut [u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<(), EcssTmtcError> {
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        self.generate_and_send_generic_tm(
-            buf,
+            src_data_buf,
            Subservice::TmInfoReport,
-            sender,
            time_stamp,
            event_id,
            aux_data,
        )
    }

-    pub fn event_low_severity(
+    pub fn event_low_severity<'time, 'src_data>(
        &mut self,
-        buf: &mut [u8],
-        sender: &mut (impl EcssTmSenderCore + ?Sized),
-        time_stamp: &[u8],
+        src_data_buf: &'src_data mut [u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<(), EcssTmtcError> {
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        self.generate_and_send_generic_tm(
-            buf,
+            src_data_buf,
            Subservice::TmLowSeverityReport,
-            sender,
            time_stamp,
            event_id,
            aux_data,
        )
    }

-    pub fn event_medium_severity(
+    pub fn event_medium_severity<'time, 'src_data>(
        &mut self,
-        buf: &mut [u8],
-        sender: &mut (impl EcssTmSenderCore + ?Sized),
-        time_stamp: &[u8],
+        buf: &'src_data mut [u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<(), EcssTmtcError> {
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        self.generate_and_send_generic_tm(
            buf,
            Subservice::TmMediumSeverityReport,
-            sender,
            time_stamp,
            event_id,
            aux_data,
        )
    }

-    pub fn event_high_severity(
+    pub fn event_high_severity<'time, 'src_data>(
        &mut self,
-        buf: &mut [u8],
-        sender: &mut (impl EcssTmSenderCore + ?Sized),
-        time_stamp: &[u8],
+        src_data_buf: &'src_data mut [u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<(), EcssTmtcError> {
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        self.generate_and_send_generic_tm(
-            buf,
+            src_data_buf,
            Subservice::TmHighSeverityReport,
-            sender,
            time_stamp,
            event_id,
            aux_data,
        )
    }

-    fn generate_and_send_generic_tm(
+    fn generate_and_send_generic_tm<'time, 'src_data>(
        &mut self,
-        buf: &mut [u8],
+        src_data_buf: &'src_data mut [u8],
        subservice: Subservice,
-        sender: &mut (impl EcssTmSenderCore + ?Sized),
-        time_stamp: &[u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<(), EcssTmtcError> {
-        let tm = self.generate_generic_event_tm(buf, subservice, time_stamp, event_id, aux_data)?;
-        sender.send_tm(tm.into())?;
-        self.msg_count += 1;
-        Ok(())
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
+        self.generate_generic_event_tm(src_data_buf, subservice, time_stamp, event_id, aux_data)
    }

-    fn generate_generic_event_tm<'a>(
-        &'a self,
-        buf: &'a mut [u8],
+    fn generate_generic_event_tm<'time, 'src_data>(
+        &self,
+        src_data_buf: &'src_data mut [u8],
        subservice: Subservice,
-        time_stamp: &'a [u8],
+        time_stamp: &'time [u8],
        event_id: impl EcssEnumeration,
-        aux_data: Option<&[u8]>,
-    ) -> Result<PusTmCreator, EcssTmtcError> {
+        aux_data: Option<&'src_data [u8]>,
+    ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
        let mut src_data_len = event_id.size();
        if let Some(aux_data) = aux_data {
            src_data_len += aux_data.len();
        }
-        source_buffer_large_enough(buf.len(), src_data_len)?;
+        source_buffer_large_enough(src_data_buf.len(), src_data_len)?;
        let mut sp_header = SpHeader::tm_unseg(self.apid, 0, 0).unwrap();
-        let sec_header = PusTmSecondaryHeader::new(
-            5,
-            subservice.into(),
-            self.msg_count,
-            self.dest_id,
-            Some(time_stamp),
-        );
+        let sec_header =
+            PusTmSecondaryHeader::new(5, subservice.into(), 0, self.dest_id, Some(time_stamp));
        let mut current_idx = 0;
-        event_id
-            .write_to_be_bytes(&mut buf[0..event_id.size()])
-            .map_err(PusError::ByteConversion)?;
+        event_id.write_to_be_bytes(&mut src_data_buf[0..event_id.size()])?;
        current_idx += event_id.size();
        if let Some(aux_data) = aux_data {
-            buf[current_idx..current_idx + aux_data.len()].copy_from_slice(aux_data);
+            src_data_buf[current_idx..current_idx + aux_data.len()].copy_from_slice(aux_data);
            current_idx += aux_data.len();
        }
        Ok(PusTmCreator::new(
            &mut sp_header,
            sec_header,
-            &buf[0..current_idx],
+            &src_data_buf[0..current_idx],
            true,
        ))
    }
@@ -161,12 +142,12 @@ mod alloc_mod {

    pub struct EventReporter {
        source_data_buf: Vec<u8>,
-        pub reporter: EventReporterBase,
+        pub reporter: EventReportCreator,
    }

    impl EventReporter {
        pub fn new(apid: u16, max_event_id_and_aux_data_size: usize) -> Option<Self> {
-            let reporter = EventReporterBase::new(apid)?;
+            let reporter = EventReportCreator::new(apid)?;
            Some(Self {
                source_data_buf: vec![0; max_event_id_and_aux_data_size],
                reporter,
@@ -179,13 +160,17 @@ mod alloc_mod {
            event_id: impl EcssEnumeration,
            aux_data: Option<&[u8]>,
        ) -> Result<(), EcssTmtcError> {
-            self.reporter.event_info(
-                self.source_data_buf.as_mut_slice(),
-                sender,
-                time_stamp,
-                event_id,
-                aux_data,
-            )
+            let tm_creator = self
+                .reporter
+                .event_info(
+                    self.source_data_buf.as_mut_slice(),
+                    time_stamp,
+                    event_id,
+                    aux_data,
+                )
+                .map_err(PusError::ByteConversion)?;
+            sender.send_tm(tm_creator.into())?;
+            Ok(())
        }

        pub fn event_low_severity(
@@ -195,13 +180,17 @@ mod alloc_mod {
            event_id: impl EcssEnumeration,
            aux_data: Option<&[u8]>,
        ) -> Result<(), EcssTmtcError> {
-            self.reporter.event_low_severity(
-                self.source_data_buf.as_mut_slice(),
-                sender,
-                time_stamp,
-                event_id,
-                aux_data,
-            )
+            let tm_creator = self
+                .reporter
+                .event_low_severity(
+                    self.source_data_buf.as_mut_slice(),
+                    time_stamp,
+                    event_id,
+                    aux_data,
+                )
+                .map_err(PusError::ByteConversion)?;
+            sender.send_tm(tm_creator.into())?;
+            Ok(())
        }

        pub fn event_medium_severity(
@@ -211,13 +200,17 @@ mod alloc_mod {
            event_id: impl EcssEnumeration,
            aux_data: Option<&[u8]>,
        ) -> Result<(), EcssTmtcError> {
-            self.reporter.event_medium_severity(
-                self.source_data_buf.as_mut_slice(),
-                sender,
-                time_stamp,
-                event_id,
-                aux_data,
-            )
+            let tm_creator = self
+                .reporter
+                .event_medium_severity(
+                    self.source_data_buf.as_mut_slice(),
+                    time_stamp,
+                    event_id,
+                    aux_data,
+                )
+                .map_err(PusError::ByteConversion)?;
+            sender.send_tm(tm_creator.into())?;
+            Ok(())
        }

        pub fn event_high_severity(
@@ -227,13 +220,17 @@ mod alloc_mod {
            event_id: impl EcssEnumeration,
            aux_data: Option<&[u8]>,
        ) -> Result<(), EcssTmtcError> {
-            self.reporter.event_high_severity(
-                self.source_data_buf.as_mut_slice(),
-                sender,
-                time_stamp,
-                event_id,
-                aux_data,
-            )
+            let tm_creator = self
+                .reporter
+                .event_high_severity(
+                    self.source_data_buf.as_mut_slice(),
+                    time_stamp,
+                    event_id,
+                    aux_data,
+                )
+                .map_err(PusError::ByteConversion)?;
+            sender.send_tm(tm_creator.into())?;
+            Ok(())
        }
    }
 }
@@ -40,19 +40,19 @@ pub use alloc_mod::*;
 pub use std_mod::*;

 #[derive(Debug, PartialEq, Eq, Clone)]
-pub enum PusTmWrapper<'tm> {
+pub enum PusTmWrapper<'time, 'src_data> {
    InStore(StoreAddr),
-    Direct(PusTmCreator<'tm>),
+    Direct(PusTmCreator<'time, 'src_data>),
 }

-impl From<StoreAddr> for PusTmWrapper<'_> {
+impl From<StoreAddr> for PusTmWrapper<'_, '_> {
    fn from(value: StoreAddr) -> Self {
        Self::InStore(value)
    }
 }

-impl<'tm> From<PusTmCreator<'tm>> for PusTmWrapper<'tm> {
-    fn from(value: PusTmCreator<'tm>) -> Self {
+impl<'time, 'src_data> From<PusTmCreator<'time, 'src_data>> for PusTmWrapper<'time, 'src_data> {
+    fn from(value: PusTmCreator<'time, 'src_data>) -> Self {
        Self::Direct(value)
    }
 }
@@ -380,7 +380,7 @@ pub mod std_mod {
    use spacepackets::ecss::tc::PusTcReader;
    use spacepackets::ecss::tm::PusTmCreator;
    use spacepackets::ecss::{PusError, WritablePusPacket};
-    use spacepackets::time::cds::TimeProvider;
+    use spacepackets::time::cds::CdsTime;
    use spacepackets::time::StdTimestampError;
    use spacepackets::time::TimeWriter;
    use std::string::String;
@@ -860,8 +860,7 @@ pub mod std_mod {
        partial_error: &mut Option<PartialPusHandlingError>,
    ) -> [u8; 7] {
        let mut time_stamp: [u8; 7] = [0; 7];
-        let time_provider =
-            TimeProvider::from_now_with_u16_days().map_err(PartialPusHandlingError::Time);
+        let time_provider = CdsTime::now_with_u16_days().map_err(PartialPusHandlingError::Time);
        if let Ok(time_provider) = time_provider {
            // Can't fail, we have a buffer with the exact required size.
            time_provider.write_to_bytes(&mut time_stamp).unwrap();
@@ -981,15 +980,16 @@ pub mod std_mod {
        >;
 }

-pub(crate) fn source_buffer_large_enough(cap: usize, len: usize) -> Result<(), EcssTmtcError> {
+pub(crate) fn source_buffer_large_enough(
+    cap: usize,
+    len: usize,
+) -> Result<(), ByteConversionError> {
    if len > cap {
-        return Err(
-            PusError::ByteConversion(ByteConversionError::ToSliceTooSmall {
-                found: cap,
-                expected: len,
-            })
-            .into(),
-        );
+        return Err(ByteConversionError::ToSliceTooSmall {
+            found: cap,
+            expected: len,
+        }
+        .into());
    }
    Ok(())
 }
@@ -14,7 +14,7 @@ use crate::pool::PoolProvider;
 use crate::pus::{PusPacketHandlerResult, PusPacketHandlingError};
 use alloc::string::ToString;
 use spacepackets::ecss::{scheduling, PusPacket};
-use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::cds::CdsTime;

 /// This is a helper class for [std] environments to handle generic PUS 11 (scheduling service)
 /// packets. This handler is able to handle the most important PUS requests for a scheduling
@@ -168,7 +168,7 @@ impl<

                // let mut pool = self.sched_tc_pool.write().expect("locking pool failed");
                self.scheduler
-                    .insert_wrapped_tc::<TimeProvider>(&tc, sched_tc_pool)
+                    .insert_wrapped_tc::<CdsTime>(&tc, sched_tc_pool)
                    .expect("insertion of activity into pool failed");

                self.service_helper
@@ -303,7 +303,7 @@ mod tests {
    }

    impl PusSchedulerProvider for TestScheduler {
-        type TimeProvider = cds::TimeProvider;
+        type TimeProvider = cds::CdsTime;

        fn reset(
            &mut self,
@@ -329,7 +329,7 @@ mod tests {

        fn insert_unwrapped_and_stored_tc(
            &mut self,
-            _time_stamp: spacepackets::time::UnixTimestamp,
+            _time_stamp: spacepackets::time::UnixTime,
            info: crate::pus::scheduler::TcInfo,
        ) -> Result<(), crate::pus::scheduler::ScheduleError> {
            self.inserted_tcs.push_back(info);
@@ -390,7 +390,7 @@ mod tests {
        let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
        let ping_tc = PusTcCreator::new(&mut reply_header, sec_header, &[], true);
        let req_id_ping_tc = scheduler::RequestId::from_tc(&ping_tc);
-        let stamper = cds::TimeProvider::from_now_with_u16_days().expect("time provider failed");
+        let stamper = cds::CdsTime::now_with_u16_days().expect("time provider failed");
        let mut sched_app_data: [u8; 64] = [0; 64];
        let mut written_len = stamper.write_to_bytes(&mut sched_app_data).unwrap();
        let ping_raw = ping_tc.to_vec().expect("generating raw tc failed");
@@ -22,7 +22,7 @@
 //! use satrs::tmtc::{ReceivesTc, ReceivesTcCore};
 //! use spacepackets::{CcsdsPacket, SpHeader};
 //! use spacepackets::ecss::WritablePusPacket;
-//! use spacepackets::ecss::tc::{PusTc, PusTcCreator};
+//! use spacepackets::ecss::tc::PusTcCreator;
 //!
 //! #[derive (Default)]
 //! struct ConcreteApidHandler {
@@ -1,5 +1,5 @@
 use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
-use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::cds::CdsTime;
 use spacepackets::time::TimeWriter;
 use spacepackets::SpHeader;

@@ -66,7 +66,7 @@ impl PusTmWithCdsShortHelper {
        source_data: &'a [u8],
        seq_count: u16,
    ) -> PusTmCreator {
-        let time_stamp = TimeProvider::from_now_with_u16_days().unwrap();
+        let time_stamp = CdsTime::now_with_u16_days().unwrap();
        time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
        self.create_pus_tm_common(service, subservice, source_data, seq_count)
    }
@@ -76,7 +76,7 @@ impl PusTmWithCdsShortHelper {
        service: u8,
        subservice: u8,
        source_data: &'a [u8],
-        stamper: &TimeProvider,
+        stamper: &CdsTime,
        seq_count: u16,
    ) -> PusTmCreator {
        stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
@@ -98,14 +98,14 @@ impl PusTmWithCdsShortHelper {

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

    use super::PusTmWithCdsShortHelper;

    #[test]
    fn test_helper_with_stamper() {
        let mut pus_tm_helper = PusTmWithCdsShortHelper::new(0x123);
-        let stamper = TimeProvider::new_with_u16_days(0, 0);
+        let stamper = CdsTime::new_with_u16_days(0, 0);
        let tm = pus_tm_helper.create_pus_tm_with_stamper(17, 1, &[1, 2, 3, 4], &stamper, 25);
        assert_eq!(tm.service(), 17);
        assert_eq!(tm.subservice(), 1);
@@ -2,7 +2,7 @@
 use core::mem::size_of;
 use serde::{Deserialize, Serialize};
 use spacepackets::ecss::{PfcReal, PfcUnsigned, Ptc};
-use spacepackets::time::cds::TimeProvider;
+use spacepackets::time::cds::CdsTime;
 use spacepackets::time::{CcsdsTimeProvider, TimeWriter};

 enum NumOfParamsInfo {
@@ -36,7 +36,7 @@ struct TestMgmHkWithIndividualValidity {

 #[derive(Serialize, Deserialize)]
 struct TestMgmHkWithGroupValidity {
-    last_valid_stamp: TimeProvider,
+    last_valid_stamp: CdsTime,
    valid: bool,
    temp: f32,
    mgm_vals: [u16; 3],
@@ -150,7 +150,7 @@ pub fn main() {
    // The easiest and probably best approach, trading off big advantages for TM downlink capacity:
    // Use a JSON format
    let mgm_hk_group_validity = TestMgmHkWithGroupValidity {
-        last_valid_stamp: TimeProvider::from_now_with_u16_days().unwrap(),
+        last_valid_stamp: CdsTime::now_with_u16_days().unwrap(),
        valid: false,
        temp: 20.0,
        mgm_vals: [0x1f1f, 0x2f2f, 0x3f3f],