need to add UDP to tmtc-utils

Reviewed-on: #264

.github/workflows/ci.yml

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

Cargo.toml

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

README.md

@@ -1,9 +1,10 @@
 <p align="center"> <img src="misc/satrs-logo-v2.png" width="40%"> </p>
 
 [![sat-rs website](https://img.shields.io/badge/sat--rs-website-darkgreen?style=flat)](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/)
-[![sat-rs book](https://img.shields.io/badge/sat--rs-book-darkgreen?style=flat)](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/book/)
+[![sat-rs book](https://img.shields.io/badge/sat--rs-book-darkgreen?style=flat)](https://robamu.github.io/sat-rs/book/)
 [![Crates.io](https://img.shields.io/crates/v/satrs)](https://crates.io/crates/satrs)
 [![docs.rs](https://img.shields.io/docsrs/satrs)](https://docs.rs/satrs)
+[![matrix chat](https://img.shields.io/matrix/sat-rs%3Amatrix.org)](https://matrix.to/#/#sat-rs:matrix.org)
 
 sat-rs
 =========
@@ -11,7 +12,7 @@ sat-rs
 This is the repository of the sat-rs library. Its primary goal is to provide re-usable components
 to write on-board software for remote systems like rovers or satellites. It is specifically written
 for the special requirements for these systems. You can find an overview of the project and the
-link to the [more high-level sat-rs book](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/)
+link to the [more high-level sat-rs book](https://robamu.github.io/sat-rs/book/)
 at the [IRS software projects website](https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/).
 
 This is early-stage software. Important features are missing. New releases
@@ -38,7 +39,7 @@ This project currently contains following crates:
    Example of a simple example on-board software using various sat-rs components which can be run
    on a host computer or on any system with a standard runtime like a Raspberry Pi.
 * [`satrs-minisim`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-minisim):
-   Mini-Simulator based on [asynchronix](https://github.com/asynchronics/asynchronix) which
+   Mini-Simulator based on [nexosim](https://github.com/asynchronics/nexosim) which
    simulates some physical devices for the `satrs-example` application device handlers.
 * [`satrs-mib`](https://egit.irs.uni-stuttgart.de/rust/sat-rs/src/branch/main/satrs-mib):
    Components to build a mission information base from the on-board software directly.
@@ -61,6 +62,8 @@ Each project has its own `CHANGELOG.md`.
    packet protocol implementations. This repository is re-exported in the
    [`satrs`](https://egit.irs.uni-stuttgart.de/rust/satrs/src/branch/main/satrs)
    crate.
+ * [`cfdp`](https://egit.irs.uni-stuttgart.de/rust/cfdp): CCSDS File Delivery Protocol
+   (CFDP) high-level library components.
 
 # Flight Heritage
 

embedded-examples/embedded-client/Cargo.toml

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

embedded-examples/embedded-client/config.toml

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

embedded-examples/embedded-client/src/bin/stm32f3-client.rs

@@ -0,0 +1,66 @@
+use std::time::Duration;
+
+use clap::Parser;
+use cobs::CobsDecoderOwned;
+use embedded_client::setup_logger;
+use embedded_models::stm32f3;
+use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
+use tmtc_utils::transport::serial::PacketTransportSerialCobs;
+
+#[derive(Parser, Debug)]
+struct Cli {
+    #[arg(short, long)]
+    ping: bool,
+
+    /// Set frequency in milliseconds.
+    #[arg(short, long)]
+    set_led_frequency: Option<u32>,
+}
+
+fn main() {
+    setup_logger().expect("failed to initialize logger");
+    println!("-- STM32F3 TMTC client --");
+    let cli = Cli::parse();
+    let config = embedded_client::Config::new_from_file();
+
+    let serial = serialport::new(config.interface.serial_port, 115200)
+        .open()
+        .expect("opening serial port failed");
+    let mut transport = PacketTransportSerialCobs::new(serial, CobsDecoderOwned::new(1024));
+
+    if cli.ping {
+        let tc = create_stm32f3_tc(&embedded_models::stm32f3::Request::Ping);
+        log::info!(
+            "Sending ping request with TC ID: {:#010x}",
+            tc.ccsds_packet_id_and_psc().raw()
+        );
+        transport.send(&tc.to_vec()).unwrap();
+    }
+
+    if let Some(freq_ms) = cli.set_led_frequency {
+        let request = stm32f3::Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        let tc = create_stm32f3_tc(&request);
+        log::info!(
+            "Sending change blink frequency request {:?} with TC ID: {:#010x}",
+            request,
+            tc.ccsds_packet_id_and_psc().raw()
+        );
+        transport.send(&tc.to_vec()).unwrap();
+    }
+
+    log::info!("Waiting for response...");
+    loop {
+        transport
+            .receive(|packet: &[u8]| {
+                let reader = CcsdsPacketReader::new_with_checksum(packet);
+                log::info!("Received packet: {:?}", reader);
+            })
+            .unwrap();
+    }
+}
+
+fn create_stm32f3_tc(request: &stm32f3::Request) -> CcsdsPacketCreatorOwned {
+    let req_raw = postcard::to_allocvec(&request).unwrap();
+    let sp_header = SpHeader::new_from_apid(satrs_stm32f3_disco_rtic::APID);
+    CcsdsPacketCreatorOwned::new_tc_with_checksum(sp_header, &req_raw).unwrap()
+}

embedded-examples/embedded-client/src/bin/stm32h7-client.rs

@@ -0,0 +1,64 @@
+use std::{fs::File, io::Read, path::Path, time::Duration};
+
+use clap::Parser;
+use cobs::CobsDecoderOwned;
+use embedded_client::setup_logger;
+use embedded_models::{stm32f3, stm32h7};
+use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
+use tmtc_utils::transport::serial::PacketTransportSerialCobs;
+
+#[derive(Parser, Debug)]
+struct Cli {
+    #[arg(short, long)]
+    ping: bool,
+
+    /// Set frequency in milliseconds.
+    #[arg(short, long)]
+    set_led_frequency: Option<u32>,
+}
+
+fn main() {
+    setup_logger().expect("failed to initialize logger");
+    println!("-- STM32H7 TMTC client --");
+    let cli = Cli::parse();
+    let config = embedded_client::Config::new_from_file();
+
+
+    /*
+    if cli.ping {
+        let tc = create_stm32f3_tc(&embedded_models::stm32f3::Request::Ping);
+        log::info!(
+            "Sending ping request with TC ID: {:#010x}",
+            tc.ccsds_packet_id_and_psc().raw()
+        );
+        transport.send(&tc.to_vec()).unwrap();
+    }
+
+    if let Some(freq_ms) = cli.set_led_frequency {
+        let request = stm32f3::Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        let tc = create_stm32f3_tc(&request);
+        log::info!(
+            "Sending change blink frequency request {:?} with TC ID: {:#010x}",
+            request,
+            tc.ccsds_packet_id_and_psc().raw()
+        );
+        transport.send(&tc.to_vec()).unwrap();
+    }
+
+    log::info!("Waiting for response...");
+    loop {
+        transport
+            .receive(|packet: &[u8]| {
+                let reader = CcsdsPacketReader::new_with_checksum(packet);
+                log::info!("Received packet: {:?}", reader);
+            })
+            .unwrap();
+    }
+    */
+}
+
+fn create_stm32h7_tc(request: &stm32h7::Request) -> CcsdsPacketCreatorOwned {
+    let req_raw = postcard::to_allocvec(&request).unwrap();
+    let sp_header = SpHeader::new_from_apid(satrs_stm32f3_disco_rtic::APID);
+    CcsdsPacketCreatorOwned::new_tc_with_checksum(sp_header, &req_raw).unwrap()
+}

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

@@ -0,0 +1,42 @@
+use std::{fs::File, io::Read as _, path::Path, time::SystemTime};
+
+#[derive(Debug, serde::Deserialize)]
+pub struct Config {
+    pub interface: Interface,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct Interface {
+    pub serial_port: String,
+}
+
+impl Config {
+    pub fn new_from_file() -> Self {
+        let mut config_file =
+            File::open(Path::new("config.toml")).expect("opening config.toml file failed");
+        let mut toml_str = String::new();
+        config_file
+            .read_to_string(&mut toml_str)
+            .expect("reading config.toml file failed");
+        let config: Config = toml::from_str(&toml_str).expect("parsing config.toml file failed");
+        println!("Connecting to serial port {}", config.interface.serial_port);
+        config
+    }
+}
+pub fn setup_logger() -> Result<(), fern::InitError> {
+    fern::Dispatch::new()
+        .format(|out, message, record| {
+            out.finish(format_args!(
+                "[{} {} {}] {}",
+                humantime::format_rfc3339_seconds(SystemTime::now()),
+                record.level(),
+                record.target(),
+                message
+            ))
+        })
+        .level(log::LevelFilter::Debug)
+        .chain(std::io::stdout())
+        .chain(fern::log_file("output.log")?)
+        .apply()?;
+    Ok(())
+}

embedded-examples/models/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "embedded-models"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+serde = { version = "1", default-features = false }
+defmt = { version = "1", optional = true }
+spacepackets = { version = "0.17", default-features = false, features = ["defmt", "serde"] }
+postcard = { version = "1", features = ["defmt"] }
+arbitrary-int = "2"

embedded-examples/models/src/lib.rs

@@ -0,0 +1,84 @@
+#![no_std]
+
+use spacepackets::{
+    CcsdsPacketCreationError, CcsdsPacketCreatorWithReservedData, CcsdsPacketIdAndPsc,
+    SpacePacketHeader, ccsds_packet_len_for_user_data_len_with_checksum,
+};
+
+pub mod stm32f3 {
+    use arbitrary_int::u11;
+    use core::time::Duration;
+
+    pub const PUS_APID: u11 = u11::new(0x02);
+
+    #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub enum Request {
+        Ping,
+        ChangeBlinkFrequency(Duration),
+    }
+
+    #[derive(Debug, serde::Serialize, serde::Deserialize)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub enum Response {
+        Ok,
+    }
+}
+
+/// This might look like a duplication, but we intentionally keep those separate so they can
+/// change independently.
+pub mod stm32h7 {
+    use arbitrary_int::u11;
+    use core::time::Duration;
+
+    pub const PUS_APID: u11 = u11::new(0x03);
+
+    #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub enum Request {
+        Ping,
+        ChangeBlinkFrequency(Duration),
+    }
+
+    #[derive(Debug, serde::Serialize, serde::Deserialize)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub enum Response {
+        Ok,
+    }
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct TmHeader {
+    pub tc_packet_id: Option<CcsdsPacketIdAndPsc>,
+    pub uptime_millis: u64,
+}
+
+pub fn tm_size<Response: serde::Serialize>(tm_header: &TmHeader, response: &Response) -> usize {
+    ccsds_packet_len_for_user_data_len_with_checksum(
+        postcard::experimental::serialized_size(tm_header).unwrap()
+            + postcard::experimental::serialized_size(response).unwrap(),
+    )
+    .unwrap()
+}
+
+pub fn create_tm_packet<Response: serde::Serialize>(
+    buf: &mut [u8],
+    sp_header: SpacePacketHeader,
+    tm_header: TmHeader,
+    response: Response,
+) -> Result<usize, CcsdsPacketCreationError> {
+    let packet_data_size = postcard::experimental::serialized_size(&tm_header).unwrap()
+        + postcard::experimental::serialized_size(&response).unwrap();
+    let mut creator =
+        CcsdsPacketCreatorWithReservedData::new_tm_with_checksum(sp_header, packet_data_size, buf)?;
+
+    let current_index = postcard::to_slice(&tm_header, creator.packet_data_mut())
+        .unwrap()
+        .len();
+    postcard::to_slice(&response, &mut creator.packet_data_mut()[current_index..]).unwrap();
+    Ok(creator.finish())
+}
+
+#[cfg(test)]
+mod tests {}

embedded-examples/stm32f3-disco-rtic/.cargo/config.toml.template

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

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

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

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

@@ -7,51 +7,31 @@ default-run = "satrs-stm32f3-disco-rtic"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+embedded-models = { path = "../models", features = ["defmt"] }
 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 = ["defmt", "stm32f303vc", "unstable-pac"] }
 enumset = "1"
-heapless = "0.8"
+heapless = "0.9"
+spacepackets = { version = "0.17", default-features = false, features = ["defmt", "serde"] }
+static_cell = "2"
+cobs = { version = "0.5", default-features = false, features = ["defmt"] }
+postcard = { version = "1" }
+arbitrary-int = "2"
+thiserror = { version = "2", default-features = false }
+serde = { version = "1", default-features = false, features = ["derive"] }
 
-[dependencies.rtic]
-version = "2"
-features = ["thumbv7-backend"]
-
-[dependencies.rtic-monotonics]
-version = "2"
-features = ["cortex-m-systick"]
-
-[dependencies.cobs]
-version = "0.3"
-default-features = false
-
-[dependencies.stm32f3xx-hal]
-git = "https://github.com/robamu/stm32f3xx-hal"
-version = "0.11.0-alpha.0"
-features = ["stm32f303xc", "rt", "enumset"]
-branch = "complete-dma-update"
-# Can be used in workspace to develop and update HAL
-# path = "../stm32f3xx-hal"
-
-[dependencies.stm32f3-discovery]
-git = "https://github.com/robamu/stm32f3-discovery"
-version = "0.8.0-alpha.0"
-branch = "complete-dma-update-hal"
-# Can be used in workspace to develop and update BSP
-# path = "../stm32f3-discovery"
-
-[dependencies.satrs]
-# path = "satrs"
-version = "0.2"
-default-features = false
-features = ["defmt"]
+rtic = { version = "2", features = ["thumbv7-backend"] }
+rtic-sync = { version = "1" }
+rtic-monotonics = { version = "2", features = ["cortex-m-systick"] }
 
 [dev-dependencies]
-defmt-test = "0.3"
+defmt-test = "0.4"
 
 # cargo test
 [profile.test]

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

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

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

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

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

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

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

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

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

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

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

@@ -1,305 +0,0 @@
-#!/usr/bin/env python3
-"""Example client for the sat-rs example application"""
-import struct
-import logging
-import sys
-import time
-from typing import Any, Optional, cast
-from prompt_toolkit.history import FileHistory, History
-from spacepackets.ecss.tm import CdsShortTimestamp
-
-import tmtccmd
-from spacepackets.ecss import PusTelemetry, PusTelecommand, PusTm, PusVerificator
-from spacepackets.ecss.pus_17_test import Service17Tm
-from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
-
-from tmtccmd import TcHandlerBase, ProcedureParamsWrapper
-from tmtccmd.core.base import BackendRequest
-from tmtccmd.core.ccsds_backend import QueueWrapper
-from tmtccmd.logging import add_colorlog_console_logger
-from tmtccmd.pus import VerificationWrapper
-from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
-from tmtccmd.com import ComInterface
-from tmtccmd.config import (
-    CmdTreeNode,
-    default_json_path,
-    SetupParams,
-    HookBase,
-    params_to_procedure_conversion,
-)
-from tmtccmd.config.com import SerialCfgWrapper
-from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
-from tmtccmd.logging.pus import (
-    RegularTmtcLogWrapper,
-    RawTmtcTimedLogWrapper,
-    TimedLogWhen,
-)
-from tmtccmd.tmtc import (
-    TcQueueEntryType,
-    ProcedureWrapper,
-    TcProcedureType,
-    FeedWrapper,
-    SendCbParams,
-    DefaultPusQueueHelper,
-)
-from tmtccmd.pus.s5_fsfw_event import Service5Tm
-from spacepackets.seqcount import FileSeqCountProvider, PusFileSeqCountProvider
-from tmtccmd.util.obj_id import ObjectIdDictT
-
-_LOGGER = logging.getLogger()
-
-EXAMPLE_PUS_APID = 0x02
-
-
-class SatRsConfigHook(HookBase):
-    def __init__(self, json_cfg_path: str):
-        super().__init__(json_cfg_path)
-
-    def get_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
-        from tmtccmd.config.com import (
-            create_com_interface_default,
-            create_com_interface_cfg_default,
-        )
-
-        assert self.cfg_path is not None
-        cfg = create_com_interface_cfg_default(
-            com_if_key=com_if_key,
-            json_cfg_path=self.cfg_path,
-            space_packet_ids=None,
-        )
-        if cfg is None:
-            raise ValueError(
-                f"No valid configuration could be retrieved for the COM IF with key {com_if_key}"
-            )
-        if cfg.com_if_key == "serial_cobs":
-            cfg = cast(SerialCfgWrapper, cfg)
-            cfg.serial_cfg.serial_timeout = 0.5
-        return create_com_interface_default(cfg)
-
-    def get_command_definitions(self) -> CmdTreeNode:
-        """This function should return the root node of the command definition tree."""
-        return create_cmd_definition_tree()
-
-    def get_cmd_history(self) -> Optional[History]:
-        """Optionlly return a history class for the past command paths which will be used
-        when prompting a command path from the user in CLI mode."""
-        return FileHistory(".tmtc-history.txt")
-
-    def get_object_ids(self) -> ObjectIdDictT:
-        from tmtccmd.config.objects import get_core_object_ids
-
-        return get_core_object_ids()
-
-
-def create_cmd_definition_tree() -> CmdTreeNode:
-    root_node = CmdTreeNode.root_node()
-    root_node.add_child(CmdTreeNode("ping", "Send PUS ping TC"))
-    root_node.add_child(CmdTreeNode("change_blink_freq", "Change blink frequency"))
-    return root_node
-
-
-class PusHandler(SpecificApidHandlerBase):
-    def __init__(
-        self,
-        file_logger: logging.Logger,
-        verif_wrapper: VerificationWrapper,
-        raw_logger: RawTmtcTimedLogWrapper,
-    ):
-        super().__init__(EXAMPLE_PUS_APID, None)
-        self.file_logger = file_logger
-        self.raw_logger = raw_logger
-        self.verif_wrapper = verif_wrapper
-
-    def handle_tm(self, packet: bytes, _user_args: Any):
-        try:
-            pus_tm = PusTm.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
-            )
-        except ValueError as e:
-            _LOGGER.warning("Could not generate PUS TM object from raw data")
-            _LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
-            raise e
-        service = pus_tm.service
-        tm_packet = None
-        if service == 1:
-            tm_packet = Service1Tm.unpack(
-                data=packet, params=UnpackParams(CdsShortTimestamp.TIMESTAMP_SIZE, 1, 2)
-            )
-            res = self.verif_wrapper.add_tm(tm_packet)
-            if res is None:
-                _LOGGER.info(
-                    f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
-                    f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
-                )
-                _LOGGER.warning(
-                    f"No matching telecommand found for {tm_packet.tc_req_id}"
-                )
-            else:
-                self.verif_wrapper.log_to_console(tm_packet, res)
-                self.verif_wrapper.log_to_file(tm_packet, res)
-        if service == 3:
-            _LOGGER.info("No handling for HK packets implemented")
-            _LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
-            pus_tm = PusTelemetry.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-            if pus_tm.subservice == 25:
-                if len(pus_tm.source_data) < 8:
-                    raise ValueError("No addressable ID in HK packet")
-                json_str = pus_tm.source_data[8:]
-                _LOGGER.info("received JSON string: " + json_str.decode("utf-8"))
-        if service == 5:
-            tm_packet = Service5Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-        if service == 17:
-            tm_packet = Service17Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-            if tm_packet.subservice == 2:
-                _LOGGER.info("Received Ping Reply TM[17,2]")
-            else:
-                _LOGGER.info(
-                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
-                )
-        if tm_packet is None:
-            _LOGGER.info(
-                f"The service {service} is not implemented in Telemetry Factory"
-            )
-            tm_packet = PusTelemetry.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-        self.raw_logger.log_tm(pus_tm)
-
-
-def make_addressable_id(target_id: int, unique_id: int) -> bytes:
-    byte_string = bytearray(struct.pack("!I", target_id))
-    byte_string.extend(struct.pack("!I", unique_id))
-    return byte_string
-
-
-class TcHandler(TcHandlerBase):
-    def __init__(
-        self,
-        seq_count_provider: FileSeqCountProvider,
-        verif_wrapper: VerificationWrapper,
-    ):
-        super(TcHandler, self).__init__()
-        self.seq_count_provider = seq_count_provider
-        self.verif_wrapper = verif_wrapper
-        self.queue_helper = DefaultPusQueueHelper(
-            queue_wrapper=QueueWrapper.empty(),
-            tc_sched_timestamp_len=7,
-            seq_cnt_provider=seq_count_provider,
-            pus_verificator=verif_wrapper.pus_verificator,
-            default_pus_apid=EXAMPLE_PUS_APID,
-        )
-
-    def send_cb(self, send_params: SendCbParams):
-        entry_helper = send_params.entry
-        if entry_helper.is_tc:
-            if entry_helper.entry_type == TcQueueEntryType.PUS_TC:
-                pus_tc_wrapper = entry_helper.to_pus_tc_entry()
-                pus_tc_wrapper.pus_tc.seq_count = (
-                    self.seq_count_provider.get_and_increment()
-                )
-                self.verif_wrapper.add_tc(pus_tc_wrapper.pus_tc)
-                raw_tc = pus_tc_wrapper.pus_tc.pack()
-                _LOGGER.info(f"Sending {pus_tc_wrapper.pus_tc}")
-                send_params.com_if.send(raw_tc)
-        elif entry_helper.entry_type == TcQueueEntryType.LOG:
-            log_entry = entry_helper.to_log_entry()
-            _LOGGER.info(log_entry.log_str)
-
-    def queue_finished_cb(self, info: ProcedureWrapper):
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
-            _LOGGER.info(f"Queue handling finished for command {def_proc.cmd_path}")
-
-    def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
-        q = self.queue_helper
-        q.queue_wrapper = wrapper.queue_wrapper
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
-            cmd_path = def_proc.cmd_path
-            if cmd_path == "/ping":
-                q.add_log_cmd("Sending PUS ping telecommand")
-                q.add_pus_tc(PusTelecommand(service=17, subservice=1))
-            if cmd_path == "/change_blink_freq":
-                self.create_change_blink_freq_command(q)
-
-    def create_change_blink_freq_command(self, q: DefaultPusQueueHelper):
-        q.add_log_cmd("Changing blink frequency")
-        while True:
-            blink_freq = int(
-                input(
-                    "Please specify new blink frequency in ms. Valid Range [2..10000]: "
-                )
-            )
-            if blink_freq < 2 or blink_freq > 10000:
-                print(
-                    "Invalid blink frequency. Please specify a value between 2 and 10000."
-                )
-                continue
-            break
-        app_data = struct.pack("!I", blink_freq)
-        q.add_pus_tc(PusTelecommand(service=8, subservice=1, app_data=app_data))
-
-
-def main():
-    add_colorlog_console_logger(_LOGGER)
-    tmtccmd.init_printout(False)
-    hook_obj = SatRsConfigHook(json_cfg_path=default_json_path())
-    parser_wrapper = PreArgsParsingWrapper()
-    parser_wrapper.create_default_parent_parser()
-    parser_wrapper.create_default_parser()
-    parser_wrapper.add_def_proc_args()
-    params = SetupParams()
-    post_args_wrapper = parser_wrapper.parse(hook_obj, params)
-    proc_wrapper = ProcedureParamsWrapper()
-    if post_args_wrapper.use_gui:
-        post_args_wrapper.set_params_without_prompts(proc_wrapper)
-    else:
-        post_args_wrapper.set_params_with_prompts(proc_wrapper)
-    params.apid = EXAMPLE_PUS_APID
-    setup_args = SetupWrapper(
-        hook_obj=hook_obj, setup_params=params, proc_param_wrapper=proc_wrapper
-    )
-    # Create console logger helper and file loggers
-    tmtc_logger = RegularTmtcLogWrapper()
-    file_logger = tmtc_logger.logger
-    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
-    verificator = PusVerificator()
-    verification_wrapper = VerificationWrapper(verificator, _LOGGER, file_logger)
-    # Create primary TM handler and add it to the CCSDS Packet Handler
-    tm_handler = PusHandler(file_logger, verification_wrapper, raw_logger)
-    ccsds_handler = CcsdsTmHandler(generic_handler=None)
-    ccsds_handler.add_apid_handler(tm_handler)
-
-    # Create TC handler
-    seq_count_provider = PusFileSeqCountProvider()
-    tc_handler = TcHandler(seq_count_provider, verification_wrapper)
-    tmtccmd.setup(setup_args=setup_args)
-    init_proc = params_to_procedure_conversion(setup_args.proc_param_wrapper)
-    tmtc_backend = tmtccmd.create_default_tmtc_backend(
-        setup_wrapper=setup_args,
-        tm_handler=ccsds_handler,
-        tc_handler=tc_handler,
-        init_procedure=init_proc,
-    )
-    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=hook_obj)
-    try:
-        while True:
-            state = tmtc_backend.periodic_op(None)
-            if state.request == BackendRequest.TERMINATION_NO_ERROR:
-                sys.exit(0)
-            elif state.request == BackendRequest.DELAY_IDLE:
-                _LOGGER.info("TMTC Client in IDLE mode")
-                time.sleep(3.0)
-            elif state.request == BackendRequest.DELAY_LISTENER:
-                time.sleep(0.8)
-            elif state.request == BackendRequest.DELAY_CUSTOM:
-                if state.next_delay.total_seconds() <= 0.4:
-                    time.sleep(state.next_delay.total_seconds())
-                else:
-                    time.sleep(0.4)
-            elif state.request == BackendRequest.CALL_NEXT:
-                pass
-    except KeyboardInterrupt:
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

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

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

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

@@ -1,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;
+        }
     }
 }

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

@@ -1,51 +1,144 @@
 #![no_main]
 #![no_std]
 
-use cortex_m_semihosting::debug;
+use defmt_rtt as _;
 
-use defmt_brtt as _; // global logger
+use arbitrary_int::u11;
+use embassy_stm32::gpio::Output;
 
-use stm32f3xx_hal as _; // memory layout
+pub const APID: u11 = u11::new(0x02);
 
-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()
+#[derive(defmt::Format, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Copy)]
+pub enum Direction {
+    North,
+    NorthEast,
+    East,
+    SouthEast,
+    South,
+    SouthWest,
+    West,
+    NorthWest,
 }
 
-/// Terminates the application and makes a semihosting-capable debug tool exit
-/// with status code 0.
-pub fn exit() -> ! {
-    loop {
-        debug::exit(debug::EXIT_SUCCESS);
+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)
     }
 }
 
-/// Hardfault handler.
-///
-/// Terminates the application and makes a semihosting-capable debug tool exit
-/// with an error. This seems better than the default, which is to spin in a
-/// loop.
-#[cortex_m_rt::exception]
-unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
-    loop {
-        debug::exit(debug::EXIT_FAILURE);
+pub struct 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);
     }
 }
 
-// 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;
+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>,
+}
 
-    #[test]
-    fn it_works() {
-        assert!(true)
+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,
+        }
     }
 }

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

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

embedded-examples/stm32h7-nucleo-rtic/.cargo/def_config.toml

@@ -1,29 +0,0 @@
-[target.'cfg(all(target_arch = "arm", target_os = "none"))']
-runner = "probe-rs run --chip STM32H743ZITx"
-# runner = ["probe-rs", "run", "--chip", "$CHIP", "--log-format", "{L} {s}"]
-
-rustflags = [
-  "-C", "linker=flip-link",
-  "-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",
-  # Can be useful for debugging.
-  # "-Clink-args=-Map=app.map"
-]
-
-[build]
-# (`thumbv6m-*` is compatible with all ARM Cortex-M chips but using the right
-# target improves performance)
-# target = "thumbv6m-none-eabi"    # Cortex-M0 and Cortex-M0+
-# target = "thumbv7m-none-eabi"    # Cortex-M3
-# target = "thumbv7em-none-eabi"   # Cortex-M4 and Cortex-M7 (no FPU)
-target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
-
-[alias]
-rb = "run --bin"
-rrb = "run --release --bin"
-
-[env]
-DEFMT_LOG = "info"

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

@@ -14,37 +14,28 @@ name = "integration"
 harness = false
 
 [dependencies]
+embedded-models = { path = "../models", features = ["defmt"] }
+
 cortex-m = { version = "0.7", features = ["critical-section-single-core"] }
+arbitrary-int = "2"
 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"] }
-cortex-m-semihosting = "0.5.0"
-stm32h7xx-hal = { version="0.16", features= ["stm32h743v", "ethernet"] }
-embedded-alloc = "0.6"
-rtic-sync = { version = "1", features = ["defmt-03"] }
+defmt = "1"
+defmt-rtt = "1"
+panic-probe = { version = "1", features = ["print-defmt"] }
+embedded-alloc = "0.7"
+static_cell = "2"
+rtic = { version = "2", features = ["thumbv7-backend"] }
+spacepackets = { version = "0.17", default-features = false, features = ["defmt"] }
+postcard = "1"
 
-[dependencies.smoltcp]
-version = "0.11"
-default-features = false
-features = ["medium-ethernet", "proto-ipv4", "socket-raw", "socket-dhcpv4", "socket-udp", "defmt"]
+embassy-stm32 =  { git = "https://github.com/embassy-rs/embassy.git", rev = "dd8e4c14e53f088bae27c5d841ab7a4fa338a52c", version = "0.6", features = ["stm32h743zi", "memory-x", "defmt", "time-driver-any"]}
 
-[dependencies.rtic]
-version = "2"
-features = ["thumbv7-backend"]
-
-[dependencies.rtic-monotonics]
-version = "2"
-features = ["cortex-m-systick"]
-
-[dependencies.satrs]
-path = "../../satrs"
-version = "0.2"
-default-features = false
-features = ["defmt", "heapless"]
+embassy-time = { git = "https://github.com/embassy-rs/embassy.git", rev = "dd8e4c14e53f088bae27c5d841ab7a4fa338a52c", version = "0.5", features = ["defmt-timestamp-uptime-ms", "generic-queue-16"] }
+embassy-net = { git = "https://github.com/embassy-rs/embassy.git", rev = "dd8e4c14e53f088bae27c5d841ab7a4fa338a52c", version = "0.9", features = ["medium-ethernet", "proto-ipv4", "tcp", "udp", "auto-icmp-echo-reply", "dhcpv4", "defmt"] }
+embassy-sync = { git = "https://github.com/embassy-rs/embassy.git", rev = "dd8e4c14e53f088bae27c5d841ab7a4fa338a52c" }
 
 [dev-dependencies]
-defmt-test = "0.3"
+defmt-test = "0.5"
 
 # cargo build/run
 [profile.dev]

embedded-examples/stm32h7-nucleo-rtic/build.rs

@@ -0,0 +1,14 @@
+use std::path::PathBuf;
+use std::{env, fs};
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
+    let cargo_dir = manifest_dir.parent().unwrap().join(".cargo");
+    let config = cargo_dir.join("config.toml");
+    let config_template = cargo_dir.join("config.toml.template");
+
+    if !config.exists() && config_template.exists() {
+        fs::create_dir_all(&cargo_dir).unwrap();
+        fs::copy(&config_template, &config).unwrap();
+    }
+}

embedded-examples/stm32h7-nucleo-rtic/pyclient/.gitignore

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

embedded-examples/stm32h7-nucleo-rtic/pyclient/def_tmtc_conf.json

@@ -1,4 +0,0 @@
-{
-    "com_if": "udp",
-    "tcpip_udp_port": 7301
-}

embedded-examples/stm32h7-nucleo-rtic/pyclient/main.py

@@ -1,305 +0,0 @@
-#!/usr/bin/env python3
-"""Example client for the sat-rs example application"""
-import struct
-import logging
-import sys
-import time
-from typing import Any, Optional, cast
-from prompt_toolkit.history import FileHistory, History
-from spacepackets.ecss.tm import CdsShortTimestamp
-
-import tmtccmd
-from spacepackets.ecss import PusTelemetry, PusTelecommand, PusTm, PusVerificator
-from spacepackets.ecss.pus_17_test import Service17Tm
-from spacepackets.ecss.pus_1_verification import UnpackParams, Service1Tm
-
-from tmtccmd import TcHandlerBase, ProcedureParamsWrapper
-from tmtccmd.core.base import BackendRequest
-from tmtccmd.core.ccsds_backend import QueueWrapper
-from tmtccmd.logging import add_colorlog_console_logger
-from tmtccmd.pus import VerificationWrapper
-from tmtccmd.tmtc import CcsdsTmHandler, SpecificApidHandlerBase
-from tmtccmd.com import ComInterface
-from tmtccmd.config import (
-    CmdTreeNode,
-    default_json_path,
-    SetupParams,
-    HookBase,
-    params_to_procedure_conversion,
-)
-from tmtccmd.config.com import SerialCfgWrapper
-from tmtccmd.config import PreArgsParsingWrapper, SetupWrapper
-from tmtccmd.logging.pus import (
-    RegularTmtcLogWrapper,
-    RawTmtcTimedLogWrapper,
-    TimedLogWhen,
-)
-from tmtccmd.tmtc import (
-    TcQueueEntryType,
-    ProcedureWrapper,
-    TcProcedureType,
-    FeedWrapper,
-    SendCbParams,
-    DefaultPusQueueHelper,
-)
-from tmtccmd.pus.s5_fsfw_event import Service5Tm
-from spacepackets.seqcount import FileSeqCountProvider, PusFileSeqCountProvider
-from tmtccmd.util.obj_id import ObjectIdDictT
-
-_LOGGER = logging.getLogger()
-
-EXAMPLE_PUS_APID = 0x02
-
-
-class SatRsConfigHook(HookBase):
-    def __init__(self, json_cfg_path: str):
-        super().__init__(json_cfg_path)
-
-    def get_communication_interface(self, com_if_key: str) -> Optional[ComInterface]:
-        from tmtccmd.config.com import (
-            create_com_interface_default,
-            create_com_interface_cfg_default,
-        )
-
-        assert self.cfg_path is not None
-        cfg = create_com_interface_cfg_default(
-            com_if_key=com_if_key,
-            json_cfg_path=self.cfg_path,
-            space_packet_ids=None,
-        )
-        if cfg is None:
-            raise ValueError(
-                f"No valid configuration could be retrieved for the COM IF with key {com_if_key}"
-            )
-        if cfg.com_if_key == "serial_cobs":
-            cfg = cast(SerialCfgWrapper, cfg)
-            cfg.serial_cfg.serial_timeout = 0.5
-        return create_com_interface_default(cfg)
-
-    def get_command_definitions(self) -> CmdTreeNode:
-        """This function should return the root node of the command definition tree."""
-        return create_cmd_definition_tree()
-
-    def get_cmd_history(self) -> Optional[History]:
-        """Optionlly return a history class for the past command paths which will be used
-        when prompting a command path from the user in CLI mode."""
-        return FileHistory(".tmtc-history.txt")
-
-    def get_object_ids(self) -> ObjectIdDictT:
-        from tmtccmd.config.objects import get_core_object_ids
-
-        return get_core_object_ids()
-
-
-def create_cmd_definition_tree() -> CmdTreeNode:
-    root_node = CmdTreeNode.root_node()
-    root_node.add_child(CmdTreeNode("ping", "Send PUS ping TC"))
-    root_node.add_child(CmdTreeNode("change_blink_freq", "Change blink frequency"))
-    return root_node
-
-
-class PusHandler(SpecificApidHandlerBase):
-    def __init__(
-        self,
-        file_logger: logging.Logger,
-        verif_wrapper: VerificationWrapper,
-        raw_logger: RawTmtcTimedLogWrapper,
-    ):
-        super().__init__(EXAMPLE_PUS_APID, None)
-        self.file_logger = file_logger
-        self.raw_logger = raw_logger
-        self.verif_wrapper = verif_wrapper
-
-    def handle_tm(self, packet: bytes, _user_args: Any):
-        try:
-            pus_tm = PusTm.unpack(
-                packet, timestamp_len=CdsShortTimestamp.TIMESTAMP_SIZE
-            )
-        except ValueError as e:
-            _LOGGER.warning("Could not generate PUS TM object from raw data")
-            _LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
-            raise e
-        service = pus_tm.service
-        tm_packet = None
-        if service == 1:
-            tm_packet = Service1Tm.unpack(
-                data=packet, params=UnpackParams(CdsShortTimestamp.TIMESTAMP_SIZE, 1, 2)
-            )
-            res = self.verif_wrapper.add_tm(tm_packet)
-            if res is None:
-                _LOGGER.info(
-                    f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
-                    f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
-                )
-                _LOGGER.warning(
-                    f"No matching telecommand found for {tm_packet.tc_req_id}"
-                )
-            else:
-                self.verif_wrapper.log_to_console(tm_packet, res)
-                self.verif_wrapper.log_to_file(tm_packet, res)
-        if service == 3:
-            _LOGGER.info("No handling for HK packets implemented")
-            _LOGGER.info(f"Raw packet: 0x[{packet.hex(sep=',')}]")
-            pus_tm = PusTelemetry.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-            if pus_tm.subservice == 25:
-                if len(pus_tm.source_data) < 8:
-                    raise ValueError("No addressable ID in HK packet")
-                json_str = pus_tm.source_data[8:]
-                _LOGGER.info("received JSON string: " + json_str.decode("utf-8"))
-        if service == 5:
-            tm_packet = Service5Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-        if service == 17:
-            tm_packet = Service17Tm.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-            if tm_packet.subservice == 2:
-                _LOGGER.info("Received Ping Reply TM[17,2]")
-            else:
-                _LOGGER.info(
-                    f"Received Test Packet with unknown subservice {tm_packet.subservice}"
-                )
-        if tm_packet is None:
-            _LOGGER.info(
-                f"The service {service} is not implemented in Telemetry Factory"
-            )
-            tm_packet = PusTelemetry.unpack(packet, CdsShortTimestamp.TIMESTAMP_SIZE)
-        self.raw_logger.log_tm(pus_tm)
-
-
-def make_addressable_id(target_id: int, unique_id: int) -> bytes:
-    byte_string = bytearray(struct.pack("!I", target_id))
-    byte_string.extend(struct.pack("!I", unique_id))
-    return byte_string
-
-
-class TcHandler(TcHandlerBase):
-    def __init__(
-        self,
-        seq_count_provider: FileSeqCountProvider,
-        verif_wrapper: VerificationWrapper,
-    ):
-        super(TcHandler, self).__init__()
-        self.seq_count_provider = seq_count_provider
-        self.verif_wrapper = verif_wrapper
-        self.queue_helper = DefaultPusQueueHelper(
-            queue_wrapper=QueueWrapper.empty(),
-            tc_sched_timestamp_len=7,
-            seq_cnt_provider=seq_count_provider,
-            pus_verificator=verif_wrapper.pus_verificator,
-            default_pus_apid=EXAMPLE_PUS_APID,
-        )
-
-    def send_cb(self, send_params: SendCbParams):
-        entry_helper = send_params.entry
-        if entry_helper.is_tc:
-            if entry_helper.entry_type == TcQueueEntryType.PUS_TC:
-                pus_tc_wrapper = entry_helper.to_pus_tc_entry()
-                pus_tc_wrapper.pus_tc.seq_count = (
-                    self.seq_count_provider.get_and_increment()
-                )
-                self.verif_wrapper.add_tc(pus_tc_wrapper.pus_tc)
-                raw_tc = pus_tc_wrapper.pus_tc.pack()
-                _LOGGER.info(f"Sending {pus_tc_wrapper.pus_tc}")
-                send_params.com_if.send(raw_tc)
-        elif entry_helper.entry_type == TcQueueEntryType.LOG:
-            log_entry = entry_helper.to_log_entry()
-            _LOGGER.info(log_entry.log_str)
-
-    def queue_finished_cb(self, info: ProcedureWrapper):
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
-            _LOGGER.info(f"Queue handling finished for command {def_proc.cmd_path}")
-
-    def feed_cb(self, info: ProcedureWrapper, wrapper: FeedWrapper):
-        q = self.queue_helper
-        q.queue_wrapper = wrapper.queue_wrapper
-        if info.proc_type == TcProcedureType.TREE_COMMANDING:
-            def_proc = info.to_tree_commanding_procedure()
-            cmd_path = def_proc.cmd_path
-            if cmd_path == "/ping":
-                q.add_log_cmd("Sending PUS ping telecommand")
-                q.add_pus_tc(PusTelecommand(service=17, subservice=1))
-            if cmd_path == "/change_blink_freq":
-                self.create_change_blink_freq_command(q)
-
-    def create_change_blink_freq_command(self, q: DefaultPusQueueHelper):
-        q.add_log_cmd("Changing blink frequency")
-        while True:
-            blink_freq = int(
-                input(
-                    "Please specify new blink frequency in ms. Valid Range [2..10000]: "
-                )
-            )
-            if blink_freq < 2 or blink_freq > 10000:
-                print(
-                    "Invalid blink frequency. Please specify a value between 2 and 10000."
-                )
-                continue
-            break
-        app_data = struct.pack("!I", blink_freq)
-        q.add_pus_tc(PusTelecommand(service=8, subservice=1, app_data=app_data))
-
-
-def main():
-    add_colorlog_console_logger(_LOGGER)
-    tmtccmd.init_printout(False)
-    hook_obj = SatRsConfigHook(json_cfg_path=default_json_path())
-    parser_wrapper = PreArgsParsingWrapper()
-    parser_wrapper.create_default_parent_parser()
-    parser_wrapper.create_default_parser()
-    parser_wrapper.add_def_proc_args()
-    params = SetupParams()
-    post_args_wrapper = parser_wrapper.parse(hook_obj, params)
-    proc_wrapper = ProcedureParamsWrapper()
-    if post_args_wrapper.use_gui:
-        post_args_wrapper.set_params_without_prompts(proc_wrapper)
-    else:
-        post_args_wrapper.set_params_with_prompts(proc_wrapper)
-    params.apid = EXAMPLE_PUS_APID
-    setup_args = SetupWrapper(
-        hook_obj=hook_obj, setup_params=params, proc_param_wrapper=proc_wrapper
-    )
-    # Create console logger helper and file loggers
-    tmtc_logger = RegularTmtcLogWrapper()
-    file_logger = tmtc_logger.logger
-    raw_logger = RawTmtcTimedLogWrapper(when=TimedLogWhen.PER_HOUR, interval=1)
-    verificator = PusVerificator()
-    verification_wrapper = VerificationWrapper(verificator, _LOGGER, file_logger)
-    # Create primary TM handler and add it to the CCSDS Packet Handler
-    tm_handler = PusHandler(file_logger, verification_wrapper, raw_logger)
-    ccsds_handler = CcsdsTmHandler(generic_handler=None)
-    ccsds_handler.add_apid_handler(tm_handler)
-
-    # Create TC handler
-    seq_count_provider = PusFileSeqCountProvider()
-    tc_handler = TcHandler(seq_count_provider, verification_wrapper)
-    tmtccmd.setup(setup_args=setup_args)
-    init_proc = params_to_procedure_conversion(setup_args.proc_param_wrapper)
-    tmtc_backend = tmtccmd.create_default_tmtc_backend(
-        setup_wrapper=setup_args,
-        tm_handler=ccsds_handler,
-        tc_handler=tc_handler,
-        init_procedure=init_proc,
-    )
-    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=hook_obj)
-    try:
-        while True:
-            state = tmtc_backend.periodic_op(None)
-            if state.request == BackendRequest.TERMINATION_NO_ERROR:
-                sys.exit(0)
-            elif state.request == BackendRequest.DELAY_IDLE:
-                _LOGGER.info("TMTC Client in IDLE mode")
-                time.sleep(3.0)
-            elif state.request == BackendRequest.DELAY_LISTENER:
-                time.sleep(0.8)
-            elif state.request == BackendRequest.DELAY_CUSTOM:
-                if state.next_delay.total_seconds() <= 0.4:
-                    time.sleep(state.next_delay.total_seconds())
-                else:
-                    time.sleep(0.4)
-            elif state.request == BackendRequest.CALL_NEXT:
-                pass
-    except KeyboardInterrupt:
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

embedded-examples/stm32h7-nucleo-rtic/pyclient/requirements.txt

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

embedded-examples/stm32h7-nucleo-rtic/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+targets = ["thumbv7em-none-eabihf"]

embedded-examples/stm32h7-nucleo-rtic/src/bin/blinky.rs

@@ -5,51 +5,53 @@
 
 #![no_std]
 #![no_main]
+use rtic::app;
 use satrs_stm32h7_nucleo_rtic as _;
 
-use stm32h7xx_hal::{block, prelude::*, timer::Timer};
+#[app(device = embassy_stm32, peripherals = false, dispatchers = [SPI1])]
+mod app {
+    use embassy_stm32::gpio;
 
-use cortex_m_rt::entry;
+    #[shared]
+    struct Shared {}
 
-#[entry]
-fn main() -> ! {
-    defmt::println!("starting stm32h7 blinky example");
+    #[local]
+    struct Local {}
 
-    // Get access to the device specific peripherals from the peripheral access crate
-    let dp = stm32h7xx_hal::stm32::Peripherals::take().unwrap();
+    #[init]
+    fn init(_cx: init::Context) -> (Shared, Local) {
+        let p = embassy_stm32::init(Default::default());
+        defmt::info!("Hello World!");
+        // Configure gpio B pin 0 as a push-pull output.
+        let ld1 = gpio::Output::new(p.PB0, gpio::Level::High, gpio::Speed::Low);
+        let ld2 = gpio::Output::new(p.PB7, gpio::Level::High, gpio::Speed::Low);
+        let ld3 = gpio::Output::new(p.PB14, gpio::Level::High, gpio::Speed::Low);
 
-    // Take ownership over the RCC devices and convert them into the corresponding HAL structs
-    let rcc = dp.RCC.constrain();
+        // Schedule the blinking task
+        blink::spawn(ld1, ld2, ld3).ok();
 
-    let pwr = dp.PWR.constrain();
-    let pwrcfg = pwr.freeze();
+        (Shared {}, Local {})
+    }
 
-    // Freeze the configuration of all the clocks in the system and
-    // retrieve the Core Clock Distribution and Reset (CCDR) object
-    let rcc = rcc.use_hse(8.MHz()).bypass_hse();
-    let ccdr = rcc.freeze(pwrcfg, &dp.SYSCFG);
+    #[task()]
+    async fn blink(
+        _cx: blink::Context,
+        mut ld1: gpio::Output<'static>,
+        mut ld2: gpio::Output<'static>,
+        mut ld3: gpio::Output<'static>,
+    ) {
+        loop {
+            defmt::info!("high");
+            ld1.set_high();
+            ld2.set_high();
+            ld3.set_high();
+            embassy_time::Timer::after_millis(500).await;
 
-    // Acquire the GPIOB peripheral
-    let gpiob = dp.GPIOB.split(ccdr.peripheral.GPIOB);
-
-    // Configure gpio B pin 0 as a push-pull output.
-    let mut ld1 = gpiob.pb0.into_push_pull_output();
-
-    // Configure gpio B pin 7 as a push-pull output.
-    let mut ld2 = gpiob.pb7.into_push_pull_output();
-
-    // Configure gpio B pin 14 as a push-pull output.
-    let mut ld3 = gpiob.pb14.into_push_pull_output();
-
-    // Configure the timer to trigger an update every second
-    let mut timer = Timer::tim1(dp.TIM1, ccdr.peripheral.TIM1, &ccdr.clocks);
-    timer.start(1.Hz());
-
-    // Wait for the timer to trigger an update and change the state of the LED
-    loop {
-        ld1.toggle();
-        ld2.toggle();
-        ld3.toggle();
-        block!(timer.wait()).unwrap();
+            defmt::info!("low");
+            ld1.set_low();
+            ld2.set_low();
+            ld3.set_low();
+            embassy_time::Timer::after_millis(500).await;
+        }
     }
 }

embedded-examples/stm32h7-nucleo-rtic/src/bin/hello.rs

@@ -1,11 +1,13 @@
 #![no_main]
 #![no_std]
 
-use satrs_stm32h7_nucleo_rtic as _; // global logger + panicking-behavior + memory layout
+// global logger + panicking-behavior + memory layout
+use satrs_stm32h7_nucleo_rtic as _;
 
 #[cortex_m_rt::entry]
 fn main() -> ! {
-    defmt::println!("Hello, world!");
-
-    satrs_stm32h7_nucleo_rtic::exit()
+    loop {
+        defmt::println!("Hello, world!");
+        cortex_m::asm::delay(100_000_000);
+    }
 }

embedded-examples/stm32h7-nucleo-rtic/src/lib.rs

@@ -1,13 +1,8 @@
 #![no_main]
 #![no_std]
 
-use cortex_m_semihosting::debug;
-
-use defmt_brtt as _; // global logger
-
-// TODO(5) adjust HAL import
-use stm32h7xx_hal as _; // memory layout
-
+use defmt_rtt as _;
+use embassy_stm32 as _;
 use panic_probe as _;
 
 // same panicking *behavior* as `panic-probe` but doesn't print a panic message
@@ -17,14 +12,6 @@ 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
@@ -32,9 +19,7 @@ pub fn exit() -> ! {
 /// loop.
 #[cortex_m_rt::exception]
 unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
-    loop {
-        debug::exit(debug::EXIT_FAILURE);
-    }
+    panic!("unexpected hard fault");
 }
 
 // defmt-test 0.3.0 has the limitation that this `#[tests]` attribute can only be used

embedded-examples/stm32h7-nucleo-rtic/src/main.rs

@@ -3,422 +3,215 @@
 extern crate alloc;
 
 use rtic::app;
-use rtic_monotonics::systick::prelude::*;
-use satrs::pool::{PoolAddr, PoolProvider, StaticHeaplessMemoryPool};
-use satrs::static_subpool;
 // global logger + panicking-behavior + memory layout
+use embassy_stm32::bind_interrupts;
 use satrs_stm32h7_nucleo_rtic as _;
-use smoltcp::socket::udp::UdpMetadata;
-use smoltcp::socket::{dhcpv4, udp};
 
 use core::mem::MaybeUninit;
 use embedded_alloc::LlffHeap as Heap;
-use smoltcp::iface::{Config, Interface, SocketHandle, SocketSet, SocketStorage};
-use smoltcp::wire::{HardwareAddress, IpAddress, IpCidr};
-use stm32h7xx_hal::ethernet;
 
 const DEFAULT_BLINK_FREQ_MS: u32 = 1000;
 const PORT: u16 = 7301;
 
 const HEAP_SIZE: usize = 131_072;
 
-const TC_SOURCE_CHANNEL_DEPTH: usize = 16;
-pub type SharedPool = StaticHeaplessMemoryPool<3>;
-pub type TcSourceChannel = rtic_sync::channel::Channel<PoolAddr, TC_SOURCE_CHANNEL_DEPTH>;
-pub type TcSourceTx = rtic_sync::channel::Sender<'static, PoolAddr, TC_SOURCE_CHANNEL_DEPTH>;
-pub type TcSourceRx = rtic_sync::channel::Receiver<'static, PoolAddr, TC_SOURCE_CHANNEL_DEPTH>;
-
 #[global_allocator]
 static HEAP: Heap = Heap::empty();
 
-systick_monotonic!(Mono, 1000);
-
-// We place the memory pool buffers inside the larger AXISRAM.
-pub const SUBPOOL_SMALL_NUM_BLOCKS: u16 = 32;
-pub const SUBPOOL_SMALL_BLOCK_SIZE: usize = 32;
-pub const SUBPOOL_MEDIUM_NUM_BLOCKS: u16 = 16;
-pub const SUBPOOL_MEDIUM_BLOCK_SIZE: usize = 128;
-pub const SUBPOOL_LARGE_NUM_BLOCKS: u16 = 8;
-pub const SUBPOOL_LARGE_BLOCK_SIZE: usize = 2048;
-
-// This data will be held by Net through a mutable reference
-pub struct NetStorageStatic<'a> {
-    socket_storage: [SocketStorage<'a>; 8],
-}
-// MaybeUninit allows us write code that is correct even if STORE is not
-// initialised by the runtime
-static mut STORE: MaybeUninit<NetStorageStatic> = MaybeUninit::uninit();
-
-static mut UDP_RX_META: [udp::PacketMetadata; 12] = [udp::PacketMetadata::EMPTY; 12];
-static mut UDP_RX: [u8; 2048] = [0; 2048];
-static mut UDP_TX_META: [udp::PacketMetadata; 12] = [udp::PacketMetadata::EMPTY; 12];
-static mut UDP_TX: [u8; 2048] = [0; 2048];
-
 /// Locally administered MAC address
 const MAC_ADDRESS: [u8; 6] = [0x02, 0x00, 0x11, 0x22, 0x33, 0x44];
 
-pub struct Net {
-    iface: Interface,
-    ethdev: ethernet::EthernetDMA<4, 4>,
-    dhcp_handle: SocketHandle,
-}
+const TC_QUEUE_DEPTH: usize = 32;
+const TM_QUEUE_DEPTH: usize = 32;
 
-impl Net {
-    pub fn new(
-        sockets: &mut SocketSet<'static>,
-        mut ethdev: ethernet::EthernetDMA<4, 4>,
-        ethernet_addr: HardwareAddress,
-    ) -> Self {
-        let config = Config::new(ethernet_addr);
-        let mut iface = Interface::new(
-            config,
-            &mut ethdev,
-            smoltcp::time::Instant::from_millis(Mono::now().duration_since_epoch().to_millis()),
-        );
-        // Create sockets
-        let dhcp_socket = dhcpv4::Socket::new();
-        iface.update_ip_addrs(|addrs| {
-            let _ = addrs.push(IpCidr::new(IpAddress::v4(192, 168, 1, 99), 0));
-        });
-
-        let dhcp_handle = sockets.add(dhcp_socket);
-        Net {
-            iface,
-            ethdev,
-            dhcp_handle,
-        }
-    }
-
-    /// Polls on the ethernet interface. You should refer to the smoltcp
-    /// documentation for poll() to understand how to call poll efficiently
-    pub fn poll<'a>(&mut self, sockets: &'a mut SocketSet) -> bool {
-        let uptime = Mono::now().duration_since_epoch();
-        let timestamp = smoltcp::time::Instant::from_millis(uptime.to_millis());
-
-        self.iface.poll(timestamp, &mut self.ethdev, sockets)
-    }
-
-    pub fn poll_dhcp<'a>(&mut self, sockets: &'a mut SocketSet) -> Option<dhcpv4::Event<'a>> {
-        let opt_event = sockets.get_mut::<dhcpv4::Socket>(self.dhcp_handle).poll();
-        if let Some(event) = &opt_event {
-            match event {
-                dhcpv4::Event::Deconfigured => {
-                    defmt::info!("DHCP lost configuration");
-                    self.iface.update_ip_addrs(|addrs| addrs.clear());
-                    self.iface.routes_mut().remove_default_ipv4_route();
-                }
-                dhcpv4::Event::Configured(config) => {
-                    defmt::info!("DHCP configuration acquired");
-                    defmt::info!("IP address: {}", config.address);
-                    self.iface.update_ip_addrs(|addrs| {
-                        addrs.clear();
-                        addrs.push(IpCidr::Ipv4(config.address)).unwrap();
-                    });
-
-                    if let Some(router) = config.router {
-                        defmt::debug!("Default gateway: {}", router);
-                        self.iface
-                            .routes_mut()
-                            .add_default_ipv4_route(router)
-                            .unwrap();
-                    } else {
-                        defmt::debug!("Default gateway: None");
-                        self.iface.routes_mut().remove_default_ipv4_route();
-                    }
-                }
-            }
-        }
-        opt_event
-    }
-}
-
-pub struct UdpNet {
-    udp_handle: SocketHandle,
-    last_client: Option<UdpMetadata>,
-    tc_source_tx: TcSourceTx,
-}
-
-impl UdpNet {
-    pub fn new<'sockets>(sockets: &mut SocketSet<'sockets>, tc_source_tx: TcSourceTx) -> Self {
-        // SAFETY: The RX and TX buffers are passed here and not used anywhere else.
-        let udp_rx_buffer =
-            smoltcp::socket::udp::PacketBuffer::new(unsafe { &mut UDP_RX_META[..] }, unsafe {
-                &mut UDP_RX[..]
-            });
-        let udp_tx_buffer =
-            smoltcp::socket::udp::PacketBuffer::new(unsafe { &mut UDP_TX_META[..] }, unsafe {
-                &mut UDP_TX[..]
-            });
-        let udp_socket = smoltcp::socket::udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
-
-        let udp_handle = sockets.add(udp_socket);
-        Self {
-            udp_handle,
-            last_client: None,
-            tc_source_tx,
-        }
-    }
-
-    pub fn poll<'sockets>(
-        &mut self,
-        sockets: &'sockets mut SocketSet,
-        shared_pool: &mut SharedPool,
-    ) {
-        let socket = sockets.get_mut::<udp::Socket>(self.udp_handle);
-        if !socket.is_open() {
-            if let Err(e) = socket.bind(PORT) {
-                defmt::warn!("binding UDP socket failed: {}", e);
-            }
-        }
-        loop {
-            match socket.recv() {
-                Ok((data, client)) => {
-                    match shared_pool.add(data) {
-                        Ok(store_addr) => {
-                            if let Err(e) = self.tc_source_tx.try_send(store_addr) {
-                                defmt::warn!("TC source channel is full: {}", e);
-                            }
-                        }
-                        Err(e) => {
-                            defmt::warn!("could not add UDP packet to shared pool: {}", e);
-                        }
-                    }
-                    self.last_client = Some(client);
-                    // TODO: Implement packet wiretapping.
-                }
-                Err(e) => match e {
-                    udp::RecvError::Exhausted => {
-                        break;
-                    }
-                    udp::RecvError::Truncated => {
-                        defmt::warn!("UDP packet was truncacted");
-                    }
-                },
-            };
-        }
-    }
-}
-
-#[app(device = stm32h7xx_hal::stm32, peripherals = true)]
+#[app(device = embassy_stm32, peripherals = false)]
 mod app {
-    use core::ptr::addr_of_mut;
 
     use super::*;
-    use rtic_monotonics::fugit::MillisDurationU32;
-    use satrs::spacepackets::ecss::tc::PusTcReader;
-    use stm32h7xx_hal::ethernet::{EthernetMAC, PHY};
-    use stm32h7xx_hal::gpio::{Output, Pin};
-    use stm32h7xx_hal::prelude::*;
-    use stm32h7xx_hal::stm32::Interrupt;
+    use arbitrary_int::u14;
+    use embassy_net::udp::UdpSocket;
+    use embassy_net::StackResources;
+    use embassy_stm32::eth;
+    use embassy_stm32::gpio;
+    use embassy_stm32::peripherals;
+    use embassy_stm32::rng;
+    use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+    use embassy_time::Duration;
+    use embassy_time::Timer;
+    use embassy_time::WithTimeout as _;
+    use embedded_models::create_tm_packet;
+    use embedded_models::stm32h7;
+    use embedded_models::tm_size;
+    use embedded_models::TmHeader;
+    use spacepackets::CcsdsPacketCreationError;
+    use spacepackets::CcsdsPacketIdAndPsc;
+    use spacepackets::CcsdsPacketReader;
+    use spacepackets::SpHeader;
+    use static_cell::StaticCell;
+
+    bind_interrupts!(struct Irqs {
+        ETH => eth::InterruptHandler;
+        RNG => rng::InterruptHandler<peripherals::RNG>;
+    });
+
+    type Device = eth::Ethernet<
+        'static,
+        peripherals::ETH,
+        eth::GenericPhy<eth::Sma<'static, peripherals::ETH_SMA>>,
+    >;
 
     struct BlinkyLeds {
-        led1: Pin<'B', 7, Output>,
-        led2: Pin<'B', 14, Output>,
+        led1: gpio::Output<'static>,
+        led2: gpio::Output<'static>,
     }
 
     #[local]
     struct Local {
+        net_runner: embassy_net::Runner<'static, Device>,
+        net_stack: embassy_net::Stack<'static>,
         leds: BlinkyLeds,
-        link_led: Pin<'B', 0, Output>,
-        net: Net,
-        udp: UdpNet,
-        tc_source_rx: TcSourceRx,
-        phy: ethernet::phy::LAN8742A<EthernetMAC>,
+        link_led: gpio::Output<'static>,
+        tc_rx: embassy_sync::channel::Receiver<
+            'static,
+            NoopRawMutex,
+            alloc::vec::Vec<u8>,
+            TC_QUEUE_DEPTH,
+        >,
+        tc_tx: embassy_sync::channel::Sender<
+            'static,
+            NoopRawMutex,
+            alloc::vec::Vec<u8>,
+            TC_QUEUE_DEPTH,
+        >,
+        tm_rx: embassy_sync::channel::Receiver<
+            'static,
+            NoopRawMutex,
+            alloc::vec::Vec<u8>,
+            TM_QUEUE_DEPTH,
+        >,
+        tm_tx: embassy_sync::channel::Sender<
+            'static,
+            NoopRawMutex,
+            alloc::vec::Vec<u8>,
+            TM_QUEUE_DEPTH,
+        >,
     }
 
     #[shared]
     struct Shared {
-        blink_freq: MillisDurationU32,
-        eth_link_up: bool,
-        sockets: SocketSet<'static>,
-        shared_pool: SharedPool,
+        sequence_count: u14,
+        blink_freq: embassy_time::Duration,
     }
 
     #[init]
-    fn init(mut cx: init::Context) -> (Shared, Local) {
+    fn init(_cx: init::Context) -> (Shared, Local) {
         defmt::println!("Starting sat-rs demo application for the STM32H743ZIT");
 
-        let pwr = cx.device.PWR.constrain();
-        let pwrcfg = pwr.freeze();
+        let mut config = embassy_stm32::Config::default();
+        {
+            use embassy_stm32::rcc::*;
+            config.rcc.hsi = Some(HSIPrescaler::Div1);
+            config.rcc.csi = true;
+            config.rcc.hsi48 = Some(Default::default()); // needed for RNG
+            config.rcc.pll1 = Some(Pll {
+                source: PllSource::Hsi,
+                prediv: PllPreDiv::Div4,
+                mul: PllMul::Mul50,
+                fracn: None,
+                divp: Some(PllDiv::Div2),
+                divq: None,
+                divr: None,
+            });
+            config.rcc.sys = Sysclk::Pll1P; // 400 Mhz
+            config.rcc.ahb_pre = AHBPrescaler::Div2; // 200 Mhz
+            config.rcc.apb1_pre = APBPrescaler::Div2; // 100 Mhz
+            config.rcc.apb2_pre = APBPrescaler::Div2; // 100 Mhz
+            config.rcc.apb3_pre = APBPrescaler::Div2; // 100 Mhz
+            config.rcc.apb4_pre = APBPrescaler::Div2; // 100 Mhz
+            config.rcc.voltage_scale = VoltageScale::Scale1;
+        }
+        let periphs = embassy_stm32::init(config);
 
-        let rcc = cx.device.RCC.constrain();
-        // Try to keep the clock configuration similar to one used in STM examples:
-        // https://github.com/STMicroelectronics/STM32CubeH7/blob/master/Projects/NUCLEO-H743ZI/Examples/GPIO/GPIO_EXTI/Src/main.c
-        let ccdr = rcc
-            .sys_ck(400.MHz())
-            .hclk(200.MHz())
-            .use_hse(8.MHz())
-            .bypass_hse()
-            .pclk1(100.MHz())
-            .pclk2(100.MHz())
-            .pclk3(100.MHz())
-            .pclk4(100.MHz())
-            .freeze(pwrcfg, &cx.device.SYSCFG);
-
-        // Initialize the systick interrupt & obtain the token to prove that we did
-        Mono::start(cx.core.SYST, ccdr.clocks.sys_ck().to_Hz());
-
-        // Those are used in the smoltcp of the stm32h7xx-hal , I am not fully sure what they are
-        // good for.
-        cx.core.SCB.enable_icache();
-        cx.core.DWT.enable_cycle_counter();
-
-        let gpioa = cx.device.GPIOA.split(ccdr.peripheral.GPIOA);
-        let gpiob = cx.device.GPIOB.split(ccdr.peripheral.GPIOB);
-        let gpioc = cx.device.GPIOC.split(ccdr.peripheral.GPIOC);
-        let gpiog = cx.device.GPIOG.split(ccdr.peripheral.GPIOG);
-
-        let link_led = gpiob.pb0.into_push_pull_output();
-        let mut led1 = gpiob.pb7.into_push_pull_output();
-        let mut led2 = gpiob.pb14.into_push_pull_output();
+        let link_led = gpio::Output::new(periphs.PB0, gpio::Level::Low, gpio::Speed::Medium);
+        let mut led1 = gpio::Output::new(periphs.PB7, gpio::Level::Low, gpio::Speed::Medium);
+        let mut led2 = gpio::Output::new(periphs.PB14, gpio::Level::Low, gpio::Speed::Medium);
 
         // Criss-cross pattern looks cooler.
         led1.set_high();
         led2.set_low();
         let leds = BlinkyLeds { led1, led2 };
 
-        let rmii_ref_clk = gpioa.pa1.into_alternate::<11>();
-        let rmii_mdio = gpioa.pa2.into_alternate::<11>();
-        let rmii_mdc = gpioc.pc1.into_alternate::<11>();
-        let rmii_crs_dv = gpioa.pa7.into_alternate::<11>();
-        let rmii_rxd0 = gpioc.pc4.into_alternate::<11>();
-        let rmii_rxd1 = gpioc.pc5.into_alternate::<11>();
-        let rmii_tx_en = gpiog.pg11.into_alternate::<11>();
-        let rmii_txd0 = gpiog.pg13.into_alternate::<11>();
-        let rmii_txd1 = gpiob.pb13.into_alternate::<11>();
-
-        let mac_addr = smoltcp::wire::EthernetAddress::from_bytes(&MAC_ADDRESS);
-
-        /// Ethernet descriptor rings are a global singleton
-        #[link_section = ".sram3.eth"]
-        static mut DES_RING: MaybeUninit<ethernet::DesRing<4, 4>> = MaybeUninit::uninit();
-
-        let (eth_dma, eth_mac) = ethernet::new(
-            cx.device.ETHERNET_MAC,
-            cx.device.ETHERNET_MTL,
-            cx.device.ETHERNET_DMA,
-            (
-                rmii_ref_clk,
-                rmii_mdio,
-                rmii_mdc,
-                rmii_crs_dv,
-                rmii_rxd0,
-                rmii_rxd1,
-                rmii_tx_en,
-                rmii_txd0,
-                rmii_txd1,
-            ),
-            // SAFETY: We do not move the returned DMA struct across thread boundaries, so this
-            // should be safe according to the docs.
-            unsafe { DES_RING.assume_init_mut() },
-            mac_addr,
-            ccdr.peripheral.ETH1MAC,
-            &ccdr.clocks,
-        );
-        // Initialise ethernet PHY...
-        let mut lan8742a = ethernet::phy::LAN8742A::new(eth_mac.set_phy_addr(0));
-        lan8742a.phy_reset();
-        lan8742a.phy_init();
-
-        unsafe {
-            ethernet::enable_interrupt();
-            cx.core.NVIC.set_priority(Interrupt::ETH, 196); // Mid prio
-            cortex_m::peripheral::NVIC::unmask(Interrupt::ETH);
-        }
-
-        // unsafe: mutable reference to static storage, we only do this once
-        let store = unsafe {
-            let store_ptr = STORE.as_mut_ptr();
-
-            // Initialise the socket_storage field. Using `write` instead of
-            // assignment via `=` to not call `drop` on the old, uninitialised
-            // value
-            addr_of_mut!((*store_ptr).socket_storage).write([SocketStorage::EMPTY; 8]);
-
-            // Now that all fields are initialised we can safely use
-            // assume_init_mut to return a mutable reference to STORE
-            STORE.assume_init_mut()
-        };
-
-        let (tc_source_tx, tc_source_rx) =
-            rtic_sync::make_channel!(PoolAddr, TC_SOURCE_CHANNEL_DEPTH);
-
-        let mut sockets = SocketSet::new(&mut store.socket_storage[..]);
-        let net = Net::new(&mut sockets, eth_dma, mac_addr.into());
-        let udp = UdpNet::new(&mut sockets, tc_source_tx);
-
-        let mut shared_pool: SharedPool = StaticHeaplessMemoryPool::new(true);
-        static_subpool!(
-            SUBPOOL_SMALL,
-            SUBPOOL_SMALL_SIZES,
-            SUBPOOL_SMALL_NUM_BLOCKS as usize,
-            SUBPOOL_SMALL_BLOCK_SIZE,
-            link_section = ".axisram"
-        );
-        static_subpool!(
-            SUBPOOL_MEDIUM,
-            SUBPOOL_MEDIUM_SIZES,
-            SUBPOOL_MEDIUM_NUM_BLOCKS as usize,
-            SUBPOOL_MEDIUM_BLOCK_SIZE,
-            link_section = ".axisram"
-        );
-        static_subpool!(
-            SUBPOOL_LARGE,
-            SUBPOOL_LARGE_SIZES,
-            SUBPOOL_LARGE_NUM_BLOCKS as usize,
-            SUBPOOL_LARGE_BLOCK_SIZE,
-            link_section = ".axisram"
+        static PACKETS: StaticCell<eth::PacketQueue<4, 4>> = StaticCell::new();
+        // warning: Not all STM32H7 devices have the exact same pins here
+        // for STM32H747XIH, replace p.PB13 for PG12
+        let device = eth::Ethernet::new(
+            PACKETS.init(eth::PacketQueue::<4, 4>::new()),
+            periphs.ETH,
+            Irqs,
+            periphs.PA1,  // ref_clk
+            periphs.PA7,  // CRS_DV: Carrier Sense
+            periphs.PC4,  // RX_D0: Received Bit 0
+            periphs.PC5,  // RX_D1: Received Bit 1
+            periphs.PG13, // TX_D0: Transmit Bit 0
+            periphs.PB13, // TX_D1: Transmit Bit 1
+            periphs.PG11, // TX_EN: Transmit Enable
+            MAC_ADDRESS,
+            periphs.ETH_SMA,
+            periphs.PA2, // mdio
+            periphs.PC1, // mdc
         );
 
-        shared_pool
-            .grow(
-                SUBPOOL_SMALL.get_mut().unwrap(),
-                SUBPOOL_SMALL_SIZES.get_mut().unwrap(),
-                SUBPOOL_SMALL_NUM_BLOCKS,
-                true,
-            )
-            .expect("growing heapless memory pool failed");
-        shared_pool
-            .grow(
-                SUBPOOL_MEDIUM.get_mut().unwrap(),
-                SUBPOOL_MEDIUM_SIZES.get_mut().unwrap(),
-                SUBPOOL_MEDIUM_NUM_BLOCKS,
-                true,
-            )
-            .expect("growing heapless memory pool failed");
-        shared_pool
-            .grow(
-                SUBPOOL_LARGE.get_mut().unwrap(),
-                SUBPOOL_LARGE_SIZES.get_mut().unwrap(),
-                SUBPOOL_LARGE_NUM_BLOCKS,
-                true,
-            )
-            .expect("growing heapless memory pool failed");
+        let config = embassy_net::Config::dhcpv4(embassy_net::DhcpConfig::default());
+
+        // Generate random seed.
+        let mut rng = rng::Rng::new(periphs.RNG, Irqs);
+        let mut seed = [0; 8];
+        rng.fill_bytes(&mut seed);
+        let seed = u64::from_le_bytes(seed);
+
+        // Init network stack
+        static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();
+        let (stack, runner) =
+            embassy_net::new(device, config, RESOURCES.init(StackResources::new()), seed);
 
         // Set up global allocator. Use AXISRAM for the heap.
         #[link_section = ".axisram"]
         static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
         unsafe { HEAP.init(&raw mut HEAP_MEM as usize, HEAP_SIZE) }
 
-        eth_link_check::spawn().expect("eth link check failed");
+        static TC_CHANNEL: static_cell::ConstStaticCell<
+            embassy_sync::channel::Channel<NoopRawMutex, alloc::vec::Vec<u8>, TC_QUEUE_DEPTH>,
+        > = static_cell::ConstStaticCell::new(embassy_sync::channel::Channel::new());
+        let tc_channel = TC_CHANNEL.take();
+        let tc_sender = tc_channel.sender();
+        let tc_receiver = tc_channel.receiver();
+
+        static TM_CHANNEL: static_cell::ConstStaticCell<
+            embassy_sync::channel::Channel<NoopRawMutex, alloc::vec::Vec<u8>, TM_QUEUE_DEPTH>,
+        > = static_cell::ConstStaticCell::new(embassy_sync::channel::Channel::new());
+        let tm_channel = TM_CHANNEL.take();
+        let tm_sender = tm_channel.sender();
+        let tm_receiver = tm_channel.receiver();
+
+        net_lib_task::spawn().expect("spawning net library task failed");
+        net_app_task::spawn().expect("spawning net application task failed");
         blinky::spawn().expect("spawning blink task failed");
-        udp_task::spawn().expect("spawning UDP task failed");
-        tc_source_task::spawn().expect("spawning TC source task failed");
+        tc_handler::spawn().expect("spawning TC handler task failed");
 
         (
             Shared {
-                blink_freq: MillisDurationU32::from_ticks(DEFAULT_BLINK_FREQ_MS),
-                eth_link_up: false,
-                sockets,
-                shared_pool,
+                blink_freq: Duration::from_millis(DEFAULT_BLINK_FREQ_MS as u64),
+                sequence_count: u14::new(0),
             },
             Local {
                 link_led,
                 leds,
-                net,
-                udp,
-                tc_source_rx,
-                phy: lan8742a,
+                net_runner: runner,
+                net_stack: stack,
+                tc_tx: tc_sender,
+                tc_rx: tc_receiver,
+                tm_tx: tm_sender,
+                tm_rx: tm_receiver,
             },
         )
     }
@@ -430,94 +223,159 @@ mod app {
             leds.led1.toggle();
             leds.led2.toggle();
             let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
-            Mono::delay(current_blink_freq).await;
+            Timer::after_millis(current_blink_freq.as_millis()).await;
         }
     }
 
-    /// This task checks for the network link.
-    #[task(local=[link_led, phy], shared=[eth_link_up])]
-    async fn eth_link_check(mut cx: eth_link_check::Context) {
-        let phy = cx.local.phy;
-        let link_led = cx.local.link_led;
+    #[task(local=[net_runner])]
+    async fn net_lib_task(cx: net_lib_task::Context) {
+        cx.local.net_runner.run().await;
+    }
+
+    #[task(local = [net_stack, link_led, tc_tx, tm_rx])]
+    async fn net_app_task(cx: net_app_task::Context) {
+        pub const MTU: usize = 1500;
+
+        // Ensure those are in the data section by making them static.
+        static RX_UDP_META: static_cell::ConstStaticCell<[embassy_net::udp::PacketMetadata; 8]> =
+            static_cell::ConstStaticCell::new([embassy_net::udp::PacketMetadata::EMPTY; 8]);
+        static TX_UDP_META: static_cell::ConstStaticCell<[embassy_net::udp::PacketMetadata; 8]> =
+            static_cell::ConstStaticCell::new([embassy_net::udp::PacketMetadata::EMPTY; 8]);
+        static TX_UDP_BUFS: static_cell::ConstStaticCell<[u8; MTU]> =
+            static_cell::ConstStaticCell::new([0; MTU]);
+        static RX_UDP_BUFS: static_cell::ConstStaticCell<[u8; MTU]> =
+            static_cell::ConstStaticCell::new([0; MTU]);
+
+        let rx_udp_meta = RX_UDP_META.take();
+        let rx_udp_bufs = RX_UDP_BUFS.take();
+        let tx_udp_meta = TX_UDP_META.take();
+        let tx_udp_bufs = TX_UDP_BUFS.take();
+
+        let mut rx_buffer = [0; MTU];
+
         loop {
-            let link_was_up = cx.shared.eth_link_up.lock(|link_up| *link_up);
-            if phy.poll_link() {
-                if !link_was_up {
-                    link_led.set_high();
-                    cx.shared.eth_link_up.lock(|link_up| *link_up = true);
-                    defmt::info!("Ethernet link up");
+            cx.local.net_stack.wait_link_up().await;
+            cx.local.link_led.set_high();
+            defmt::info!("Network link is up");
+
+            // Ensure DHCP configuration is up before trying connect
+            cx.local.net_stack.wait_config_up().await;
+
+            let config = cx.local.net_stack.config_v4();
+            defmt::info!("Network task initialized, config: {}", config);
+
+            let mut udp = UdpSocket::new(
+                cx.local.net_stack.clone(),
+                rx_udp_meta,
+                rx_udp_bufs,
+                tx_udp_meta,
+                tx_udp_bufs,
+            );
+            defmt::info!("UDP socket bound to port {}", PORT);
+            udp.bind(PORT).expect("failed to bind UDP socket");
+            let mut remote_endpoint = None;
+            loop {
+                if !cx.local.net_stack.is_link_up() {
+                    defmt::warn!("Network link is down");
+                    cx.local.link_led.set_low();
+                    break;
                 }
-            } else if link_was_up {
-                link_led.set_low();
-                cx.shared.eth_link_up.lock(|link_up| *link_up = false);
-                defmt::info!("Ethernet link down");
-            }
-            Mono::delay(100.millis()).await;
-        }
-    }
-
-    #[task(binds=ETH, local=[net], shared=[sockets])]
-    fn eth_isr(mut cx: eth_isr::Context) {
-        // SAFETY: We do not write the register mentioned inside the docs anywhere else.
-        unsafe {
-            ethernet::interrupt_handler();
-        }
-        // Check and process ETH frames and DHCP. UDP is checked in a different task.
-        cx.shared.sockets.lock(|sockets| {
-            cx.local.net.poll(sockets);
-            cx.local.net.poll_dhcp(sockets);
-        });
-    }
-
-    /// This task routes UDP packets.
-    #[task(local=[udp], shared=[sockets, shared_pool])]
-    async fn udp_task(mut cx: udp_task::Context) {
-        loop {
-            cx.shared.sockets.lock(|sockets| {
-                cx.shared.shared_pool.lock(|pool| {
-                    cx.local.udp.poll(sockets, pool);
-                })
-            });
-            Mono::delay(40.millis()).await;
-        }
-    }
-
-    /// This task handles all the incoming telecommands.
-    #[task(local=[read_buf: [u8; 1024] = [0; 1024], tc_source_rx], shared=[shared_pool])]
-    async fn tc_source_task(mut cx: tc_source_task::Context) {
-        loop {
-            let recv_result = cx.local.tc_source_rx.recv().await;
-            match recv_result {
-                Ok(pool_addr) => {
-                    cx.shared.shared_pool.lock(|pool| {
-                        match pool.read(&pool_addr, cx.local.read_buf.as_mut()) {
-                            Ok(packet_len) => {
-                                defmt::info!("received {} bytes in the TC source task", packet_len);
-                                match PusTcReader::new(&cx.local.read_buf[0..packet_len]) {
-                                    Ok((packet, _tc_len)) => {
-                                        // TODO: Handle packet here or dispatch to dedicated PUS
-                                        // handler? Dispatching could simplify some things and make
-                                        // the software more scalable..
-                                        defmt::info!("received PUS packet: {}", packet);
-                                    }
-                                    Err(e) => {
-                                        defmt::info!("invalid TC format, not a PUS packet: {}", e);
-                                    }
-                                }
-                                if let Err(e) = pool.delete(pool_addr) {
-                                    defmt::warn!("deleting TC data failed: {}", e);
-                                }
-                            }
-                            Err(e) => {
-                                defmt::warn!("TC packet read failed: {}", e);
-                            }
+                match udp
+                    .recv_from(&mut rx_buffer)
+                    .with_timeout(Duration::from_millis(200))
+                    .await
+                {
+                    Ok(result) => match result {
+                        Ok((data, meta)) => {
+                            remote_endpoint = Some(meta.endpoint);
+                            defmt::debug!("UDP RX {}, Meta: {}", data, meta);
+                            cx.local.tc_tx.send(rx_buffer[0..data].to_vec()).await;
                         }
-                    });
+                        Err(e) => {
+                            defmt::warn!("udp receive error: {}", e);
+                            Timer::after_millis(100).await;
+                        }
+                    },
+                    Err(_e) => (),
                 }
-                Err(e) => {
-                    defmt::warn!("TC source reception error: {}", e);
+                if let Some(endpoint) = remote_endpoint {
+                    while let Ok(packet) = cx.local.tm_rx.try_receive() {
+                        match udp.send_to(&packet, endpoint).await {
+                            Ok(_) => {
+                                defmt::debug!("UDP TX: {} bytes to: {}", packet.len(), endpoint)
+                            }
+                            Err(e) => defmt::warn!("udp send error: {}", e),
+                        }
+                    }
                 }
-            };
+            }
         }
     }
+
+    #[task(local = [tc_rx, tm_tx], shared=[sequence_count, blink_freq])]
+    async fn tc_handler(mut cx: tc_handler::Context) {
+        loop {
+            let tc = cx.local.tc_rx.receive().await;
+
+            match CcsdsPacketReader::new_with_checksum(&tc) {
+                Ok(packet) => {
+                    let packet_id = packet.packet_id();
+                    let psc = packet.psc();
+                    let tc_packet_id = CcsdsPacketIdAndPsc { packet_id, psc };
+                    if let Ok(request) =
+                        postcard::from_bytes::<stm32h7::Request>(packet.packet_data())
+                    {
+                        let response = match request {
+                            stm32h7::Request::Ping => {
+                                stm32h7::Response::Ok
+                            }
+                            stm32h7::Request::ChangeBlinkFrequency(duration) => {
+                                cx.shared.blink_freq.lock(|current| {
+                                    *current = Duration::from_millis(duration.as_millis() as u64)
+                                });
+                                stm32h7::Response::Ok
+                            }
+                        };
+                        let sequence_count = cx.shared.sequence_count.lock(|v| {
+                            let current = *v;
+                            *v = v.wrapping_add(u14::new(1));
+                            current
+                        });
+
+                        // Send Pong/OK response immediately.
+                        if let Err(e) =
+                            send_tm(tc_packet_id, response, sequence_count, cx.local.tm_tx).await
+                        {
+                            defmt::warn!("Failed to send TM response: {}", e);
+                        }
+                    }
+                }
+                Err(e) => defmt::warn!("Failed to parse received TC packet: {}", e,),
+            }
+            defmt::info!("Received from UDP client: {}", tc.as_slice());
+        }
+    }
+
+    async fn send_tm(
+        tc_packet_id: CcsdsPacketIdAndPsc,
+        response: stm32h7::Response,
+        current_seq_count: u14,
+        sender: &embassy_sync::channel::Sender<
+            'static,
+            NoopRawMutex,
+            alloc::vec::Vec<u8>,
+            TM_QUEUE_DEPTH,
+        >,
+    ) -> Result<(), CcsdsPacketCreationError> {
+        let sp_header = SpHeader::new_for_unseg_tc(stm32h7::PUS_APID, current_seq_count, 0);
+        let tm_header = TmHeader {
+            tc_packet_id: Some(tc_packet_id),
+            uptime_millis: embassy_time::Instant::now().as_millis(),
+        };
+        let tm_size = tm_size(&tm_header, &response);
+        let mut packet = alloc::vec![0; tm_size];
+        create_tm_packet(&mut packet, sp_header, tm_header, response)?;
+        sender.send(packet).await;
+        Ok(())
+    }
 }

embedded-examples/stm32h7-nucleo-rtic/tests/integration.rs

@@ -1,7 +1,7 @@
 #![no_std]
 #![no_main]
 
-use stm32h7_testapp as _; // memory layout + panic handler
+use satrs_stm32h7_nucleo_rtic as _; // memory layout + panic handler
 
 // See https://crates.io/crates/defmt-test/0.3.0 for more documentation (e.g. about the 'state'
 // feature)

embedded-examples/stm32h7-nucleo-rtic/vscode/.gitignore

@@ -1,2 +0,0 @@
-/settings.json
-/.cortex-debug.*

embedded-examples/stm32h7-nucleo-rtic/vscode/extensions.json

@@ -1,12 +0,0 @@
-{
-	// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
-	// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
-
-	// List of extensions which should be recommended for users of this workspace.
-	"recommendations": [
-		"rust-lang.rust",
-		"probe-rs.probe-rs-debugger"
-	],
-	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
-	"unwantedRecommendations": []
-}

embedded-examples/stm32h7-nucleo-rtic/vscode/launch.json

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

embedded-examples/stm32h7-nucleo-rtic/vscode/tasks.json

@@ -1,20 +0,0 @@
-{
-    // See https://go.microsoft.com/fwlink/?LinkId=733558 
-    // for the documentation about the tasks.json format
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "cargo build",
-            "type": "shell",
-            "command": "~/.cargo/bin/cargo", // note: full path to the cargo
-            "args": [
-                "build"
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            }
-        },
-
-    ]
-}

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"

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

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();
+        }
+    }
+}

justfile

@@ -0,0 +1,37 @@
+all: check build embedded test check-fmt clippy docs
+
+check:
+  cargo check
+  cargo check -p satrs-example --no-default-features
+
+build:
+  cargo build
+
+test:
+  cargo nextest run --all-features
+  cargo test --doc --all-features
+
+embedded: embedded-stm32h7 embedded-stm32f3
+  cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
+
+[working-directory:"embedded-examples/stm32h7-nucleo-rtic"]
+embedded-stm32h7:
+  cargo build --target=thumbv7em-none-eabihf --release
+
+[working-directory:"embedded-examples/stm32f3-disco-rtic"]
+embedded-stm32f3:
+  cargo build --target=thumbv7em-none-eabihf --release
+
+check-fmt:
+  cargo fmt --all -- --check
+
+fmt:
+  cargo fmt --all
+
+clippy:
+  cargo clippy -- -D warnings
+
+docs-satrs:
+  RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc -p satrs --all-features
+
+docs: docs-satrs

satrs-book/src/constrained-systems.md

@@ -3,20 +3,20 @@
 Software for space systems oftentimes has different requirements than the software for host
 systems or servers. Currently, most space systems are considered embedded systems.
 
-For these systems, the computation power and the available heap are the most important resources
-which are constrained. This might make completeley heap based memory management schemes which
+For these systems, the computation power and the available heap are important resources
+which are also constrained. This might make completeley heap based memory management schemes which
 are oftentimes used on host and server based systems unfeasable. Still, completely forbidding
 heap allocations might make software development unnecessarilly difficult, especially in a
 time where the OBSW might be running on Linux based systems with hundreds of MBs of RAM.
 
-A useful pattern used commonly in space systems is to limit heap allocations to program
+A useful pattern commonly used in space systems is to limit heap allocations to program
 initialization time and avoid frequent run-time allocations. This prevents issues like
 running out of memory (something even Rust can not protect from) or heap fragmentation on systems
 without a MMU.
 
 # Using pre-allocated pool structures
 
-A huge candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
+A candidate for heap allocations is the TMTC and  handling. TC, TMs and IPC data are all
 candidates where the data size might vary greatly. The regular solution for host systems
 might be to send around this data as a `Vec<u8>` until it is dropped. `sat-rs` provides
 another solution to avoid run-time allocations by offering pre-allocated static

satrs-example/Cargo.toml

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

satrs-example/client/Cargo.toml

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

satrs-example/client/src/main.rs

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

satrs-example/minisim/Cargo.toml

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

satrs-example/minisim/src/acs.rs

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

satrs-example/minisim/src/controller.rs

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

satrs-example/minisim/src/eps.rs

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

satrs-example/minisim/src/lib.rs

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

satrs-example/minisim/src/main.rs

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

satrs-example/minisim/src/udp.rs

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

satrs-example/models/Cargo.toml

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

satrs-example/models/src/ccsds.rs

@@ -0,0 +1,130 @@
+use crate::TmHeader;
+use serde::Serialize;
+use spacepackets::{
+    CcsdsPacketCreationError, CcsdsPacketCreatorWithReservedData, SpHeader, SpacePacketHeader,
+    ccsds_packet_len_for_user_data_len_with_checksum,
+};
+
+use crate::TcHeader;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CcsdsTcPacketOwned {
+    pub sp_header: SpacePacketHeader,
+    pub tc_header: TcHeader,
+    pub payload: alloc::vec::Vec<u8>,
+}
+
+impl CcsdsTcPacketOwned {
+    pub fn new_with_request<R: serde::Serialize>(
+        sp_header: SpacePacketHeader,
+        tc_header: TcHeader,
+        request: R,
+    ) -> Self {
+        let request_serialized = postcard::to_allocvec(&request).unwrap();
+        Self::new(sp_header, tc_header, request_serialized)
+    }
+
+    pub fn new(
+        sp_header: SpacePacketHeader,
+        tc_header: TcHeader,
+        payload: alloc::vec::Vec<u8>,
+    ) -> Self {
+        Self {
+            sp_header,
+            tc_header,
+            payload,
+        }
+    }
+
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, CcsdsCreationError> {
+        let response_len =
+            postcard::experimental::serialized_size(&self.tc_header)? + self.payload.len();
+        let mut ccsds_tc = CcsdsPacketCreatorWithReservedData::new_tc_with_checksum(
+            self.sp_header,
+            response_len,
+            buf,
+        )?;
+        let user_data = ccsds_tc.packet_data_mut();
+        let ser_len = postcard::to_slice(&self.tc_header, user_data)?.len();
+        user_data[ser_len..ser_len + self.payload.len()].copy_from_slice(&self.payload);
+        let ccsds_packet_len = ccsds_tc.finish();
+        Ok(ccsds_packet_len)
+    }
+
+    pub fn len_written(&self) -> usize {
+        ccsds_packet_len_for_user_data_len_with_checksum(
+            postcard::experimental::serialized_size(&self.tc_header).unwrap() as usize
+                + postcard::experimental::serialized_size(&self.payload).unwrap() as usize,
+        )
+        .unwrap()
+    }
+
+    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
+        let mut buf = alloc::vec![0u8; self.len_written()];
+        let len = self.write_to_bytes(&mut buf).unwrap();
+        buf.truncate(len);
+        buf
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CcsdsCreationError {
+    #[error("CCSDS packet creation error: {0}")]
+    CcsdsPacketCreation(#[from] CcsdsPacketCreationError),
+    #[error("postcard error: {0}")]
+    Postcard(#[from] postcard::Error),
+    #[error("timestamp generation error")]
+    Time,
+}
+
+/// Unserialized owned TM packet which can be cloned and sent around.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CcsdsTmPacketOwned {
+    pub sp_header: SpacePacketHeader,
+    pub tm_header: TmHeader,
+    pub payload: alloc::vec::Vec<u8>,
+}
+
+impl CcsdsTmPacketOwned {
+    pub fn new_with_serde_payload(
+        sp_header: SpHeader,
+        tm_header: &TmHeader,
+        payload: &impl Serialize,
+    ) -> Result<Self, postcard::Error> {
+        Ok(CcsdsTmPacketOwned {
+            sp_header,
+            tm_header: *tm_header,
+            payload: postcard::to_allocvec(&payload)?,
+        })
+    }
+
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, CcsdsCreationError> {
+        let response_len =
+            postcard::experimental::serialized_size(&self.tm_header)? + self.payload.len();
+        let mut ccsds_tm = CcsdsPacketCreatorWithReservedData::new_tm_with_checksum(
+            self.sp_header,
+            response_len,
+            buf,
+        )?;
+        let user_data = ccsds_tm.packet_data_mut();
+        let ser_len = postcard::to_slice(&self.tm_header, user_data)?.len();
+        user_data[ser_len..ser_len + self.payload.len()].copy_from_slice(&self.payload);
+        let ccsds_packet_len = ccsds_tm.finish();
+        Ok(ccsds_packet_len)
+    }
+
+    pub fn len_written(&self) -> usize {
+        ccsds_packet_len_for_user_data_len_with_checksum(
+            postcard::experimental::serialized_size(&self.tm_header).unwrap() as usize
+                + postcard::experimental::serialized_size(&self.payload).unwrap() as usize,
+        )
+        .unwrap()
+    }
+
+    pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
+        let mut buf = alloc::vec![0u8; self.len_written()];
+        let len = self.write_to_bytes(&mut buf).unwrap();
+        buf.truncate(len);
+        buf
+    }
+}

satrs-example/models/src/control.rs

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

satrs-example/models/src/lib.rs

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

satrs-example/models/src/mgm.rs

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

satrs-example/models/src/mgm_assembly.rs

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

satrs-example/models/src/pcdu.rs

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

satrs-example/src/acs/assembly.rs

@@ -1 +0,0 @@
-// TODO: Write the assembly

satrs-example/src/acs/mgm_assembly.rs

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

satrs-example/src/acs/mod.rs

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

satrs-example/src/bin/simpleclient.rs

@@ -1,82 +0,0 @@
-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_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
-use std::net::{IpAddr, SocketAddr, UdpSocket};
-use std::time::Duration;
-
-fn main() {
-    let mut buf = [0; 32];
-    let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
-    let pus_tc = PusTcCreator::new_simple(SpHeader::new_from_apid(0x02), 17, 1, &[], true);
-    let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
-    let tc_req_id = RequestId::new(&pus_tc);
-    println!("Packing and sending PUS ping command TC[17,1] with request ID {tc_req_id}");
-    let size = pus_tc
-        .write_to_bytes(&mut buf)
-        .expect("Creating PUS TC failed");
-    client
-        .send_to(&buf[0..size], addr)
-        .unwrap_or_else(|_| panic!("Sending to {addr:?} failed"));
-    client
-        .set_read_timeout(Some(Duration::from_secs(2)))
-        .expect("Setting read timeout failed");
-    loop {
-        let res = client.recv(&mut buf);
-        match res {
-            Ok(_len) => {
-                let (pus_tm, size) = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
-                if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
-                    println!("Received PUS Ping Reply TM[17,2]")
-                } else if pus_tm.service() == 1 {
-                    if pus_tm.source_data().is_empty() {
-                        println!("Invalid verification TM, no source data");
-                    }
-                    let src_data = pus_tm.source_data();
-                    if src_data.len() < 4 {
-                        println!("Invalid verification TM source data, less than 4 bytes")
-                    }
-                    let req_id = RequestId::from_bytes(src_data).unwrap();
-                    if pus_tm.subservice() == 1 {
-                        println!("Received TM[1,1] acceptance success for request ID {req_id}")
-                    } else if pus_tm.subservice() == 2 {
-                        println!("Received TM[1,2] acceptance failure for request ID {req_id}")
-                    } else if pus_tm.subservice() == 3 {
-                        println!("Received TM[1,3] start success for request ID {req_id}")
-                    } else if pus_tm.subservice() == 4 {
-                        println!("Received TM[1,2] start failure for request ID {req_id}")
-                    } else if pus_tm.subservice() == 5 {
-                        println!("Received TM[1,5] step success for request ID {req_id}")
-                    } else if pus_tm.subservice() == 6 {
-                        println!("Received TM[1,6] step failure for request ID {req_id}")
-                    } else if pus_tm.subservice() == 7 {
-                        println!("Received TM[1,7] completion success for request ID {req_id}")
-                    } else if pus_tm.subservice() == 8 {
-                        println!("Received TM[1,8] completion failure for request ID {req_id}");
-                    }
-                } else {
-                    println!(
-                        "Received TM[{}, {}] with {} bytes",
-                        pus_tm.service(),
-                        pus_tm.subservice(),
-                        size
-                    );
-                }
-            }
-            Err(ref e)
-                if e.kind() == std::io::ErrorKind::WouldBlock
-                    || e.kind() == std::io::ErrorKind::TimedOut =>
-            {
-                println!("No reply received for 2 seconds");
-                break;
-            }
-            _ => {
-                println!("UDP receive error {:?}", res.unwrap_err());
-            }
-        }
-    }
-}

satrs-example/src/bin/test.rs

@@ -1,66 +0,0 @@
-#![allow(dead_code)]
-
-use crossbeam_channel::{bounded, Receiver, Sender};
-use std::sync::atomic::{AtomicU16, Ordering};
-use std::thread;
-use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, Unaligned, U16};
-
-trait FieldDataProvider: Send {
-    fn get_data(&self) -> &[u8];
-}
-
-struct FixedFieldDataWrapper {
-    data: [u8; 8],
-}
-
-impl FixedFieldDataWrapper {
-    pub fn from_two_u32(p0: u32, p1: u32) -> Self {
-        let mut data = [0; 8];
-        data[0..4].copy_from_slice(p0.to_be_bytes().as_slice());
-        data[4..8].copy_from_slice(p1.to_be_bytes().as_slice());
-        Self { data }
-    }
-}
-
-impl FieldDataProvider for FixedFieldDataWrapper {
-    fn get_data(&self) -> &[u8] {
-        self.data.as_slice()
-    }
-}
-
-type FieldDataTraitObj = Box<dyn FieldDataProvider>;
-
-struct ExampleMgmSet {
-    mgm_vec: [f32; 3],
-    temperature: u16,
-}
-
-#[derive(FromBytes, IntoBytes, Immutable, Unaligned)]
-#[repr(C)]
-struct ExampleMgmSetZc {
-    mgm_vec: [u8; 12],
-    temperatur: U16<NetworkEndian>,
-}
-
-fn main() {
-    let (s0, r0): (Sender<FieldDataTraitObj>, Receiver<FieldDataTraitObj>) = bounded(5);
-    let data_wrapper = FixedFieldDataWrapper::from_two_u32(2, 3);
-    s0.send(Box::new(data_wrapper)).unwrap();
-    let jh0 = thread::spawn(move || {
-        let data = r0.recv().unwrap();
-        let raw = data.get_data();
-        println!("Received data {raw:?}");
-    });
-    let jh1 = thread::spawn(|| {});
-    jh0.join().unwrap();
-    jh1.join().unwrap();
-    //let mut max_val: u16 = u16::MAX;
-    //max_val += 1;
-    //println!("Max val: {}", max_val);
-    let atomic_u16: AtomicU16 = AtomicU16::new(u16::MAX);
-    atomic_u16.fetch_add(1, Ordering::SeqCst);
-    println!(
-        "atomic after overflow: {}",
-        atomic_u16.load(Ordering::SeqCst)
-    );
-}

satrs-example/src/ccsds.rs

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

satrs-example/src/config.rs

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

satrs-example/src/control.rs

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

satrs-example/src/eps/mod.rs

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

satrs-example/src/eps/pcdu.rs

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

satrs-example/src/event_manager.rs

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

satrs-example/src/interface/sim_client_udp.rs

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

satrs-example/src/interface/tcp.rs

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

satrs-example/src/interface/udp.rs

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

satrs-example/src/legacy/events.rs

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

satrs-example/src/legacy/hk.rs

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

satrs-example/src/legacy/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;
 
@@ -160,7 +161,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio
         verif_reporter: &impl VerificationReportingProvider,
         time_stamp: &[u8],
     ) -> Result<(ActivePusActionRequestStd, ActionRequest), Self::Error> {
-        let subservice = tc.subservice();
+        let subservice = tc.message_subtype_id();
         let user_data = tc.user_data();
         if user_data.len() < 8 {
             verif_reporter
@@ -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(),
@@ -269,12 +270,14 @@ impl TargetedPusService for ActionServiceWrapper {
 
 #[cfg(test)]
 mod tests {
+    use arbitrary_int::traits::Integer as _;
     use satrs::pus::test_util::{
         TEST_APID, TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
     };
     use satrs::pus::verification::test_util::TestVerificationReporter;
-    use satrs::pus::{verification, EcssTcInVecConverter};
+    use satrs::pus::{verification, EcssTcVecCacher};
     use satrs::request::MessageMetadata;
+    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::tmtc::PacketAsVec;
     use satrs::ComponentId;
     use satrs::{
@@ -324,7 +327,7 @@ mod tests {
                         pus_action_rx,
                         TmTcSender::Heap(tm_funnel_tx.clone()),
                         verif_reporter,
-                        EcssTcInMemConverter::Heap(EcssTcInVecConverter::default()),
+                        EcssTcCacher::Heap(EcssTcVecCacher::default()),
                     ),
                     ActionRequestConverter::default(),
                     DefaultActiveActionRequestMap::default(),
@@ -367,7 +370,7 @@ mod tests {
             if let Err(mpsc::TryRecvError::Empty) = packet {
             } else {
                 let tm = packet.unwrap();
-                let unexpected_tm = PusTmReader::new(&tm.packet, 7).unwrap().0;
+                let unexpected_tm = PusTmReader::new(&tm.packet, 7).unwrap();
                 panic!("unexpected TM packet {unexpected_tm:?}");
             }
         }
@@ -410,7 +413,11 @@ mod tests {
 
         pub fn add_tc(&mut self, tc: &PusTcCreator) {
             self.request_id = Some(verification::RequestId::new(tc).into());
-            let token = self.service.service_helper.verif_reporter_mut().add_tc(tc);
+            let token = self
+                .service
+                .service_helper
+                .verif_reporter_mut()
+                .start_verification(tc);
             let accepted_token = self
                 .service
                 .service_helper
@@ -443,12 +450,13 @@ mod tests {
         );
         // Create a basic action request and verify forwarding.
         let sp_header = SpHeader::new_from_apid(TEST_APID);
-        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.as_u32().to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
-        let pus8_packet = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        let pus8_packet =
+            PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
         testbench.add_tc(&pus8_packet);
         let time_stamp: [u8; 7] = [0; 7];
         testbench.verify_next_tc_is_handled_properly(&time_stamp);
@@ -484,7 +492,7 @@ mod tests {
             TEST_COMPONENT_ID_1.id(),
         );
         // Create a basic action request and verify forwarding.
-        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
         // Invalid ID, routing should fail.
@@ -494,7 +502,7 @@ mod tests {
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            true,
+            CreatorConfig::default(),
         );
         testbench.add_tc(&pus8_packet);
         let time_stamp: [u8; 7] = [0; 7];
@@ -510,17 +518,17 @@ mod tests {
             TEST_COMPONENT_ID_0.raw(),
             ActionRequestConverter::default(),
         );
-        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
         let action_id = 5_u32;
         let mut app_data: [u8; 8] = [0; 8];
         // Invalid ID, routing should fail.
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
         let pus8_packet = PusTcCreator::new(
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            true,
+            CreatorConfig::default(),
         );
         let token = testbench.add_tc(&pus8_packet);
         let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
@@ -546,11 +554,11 @@ mod tests {
     fn converter_action_req_with_data() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ActionRequestConverter::default());
-        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
         let action_id = 5_u32;
         let mut app_data: [u8; 16] = [0; 16];
         // Invalid ID, routing should fail.
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
         app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
         for i in 0..8 {
             app_data[i + 8] = i as u8;
@@ -559,7 +567,7 @@ mod tests {
             SpHeader::new_from_apid(TEST_APID),
             sec_header,
             &app_data,
-            true,
+            CreatorConfig::default(),
         );
         let token = testbench.add_tc(&pus8_packet);
         let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0);
@@ -689,7 +697,7 @@ mod tests {
             ReplyHandlerTestbench::new(TEST_COMPONENT_ID_0.id(), ActionReplyHandler::default());
         let action_reply = ActionReplyPus::new(5_u32, ActionReplyVariant::Completed);
         let unrequested_reply =
-            GenericMessage::new(MessageMetadata::new(10_u32, 15_u64), action_reply);
+            GenericMessage::new(MessageMetadata::new(10_u32, 15_u32), action_reply);
         // Right now this function does not do a lot. We simply check that it does not panic or do
         // weird stuff.
         let result = testbench.handle_unrequested_reply(&unrequested_reply);

satrs-example/src/legacy/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 {

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

satrs-example/src/legacy/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,12 +33,13 @@ 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);
     // Every software component which needs to generate verification telemetry, gets a cloned
     // verification reporter.
     VerificationReporter::new(owner_id, &verif_cfg)
 }
 
+/*
 /// Simple router structure which forwards PUS telecommands to dedicated handlers.
 pub struct PusTcMpscRouter {
     pub test_tc_sender: mpsc::SyncSender<EcssTcAndToken>,
@@ -62,12 +63,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,18 +103,18 @@ impl PusTcDistributor {
                 sender_id,
                 pus_tc_result.unwrap_err()
             );
-            log::warn!("raw data: {:x?}", raw_tc);
+            log::warn!("raw data: {raw_tc:x?}");
             // TODO: Shouldn't this be an error?
             return Ok(HandlingStatus::HandledOne);
         }
-        let pus_tc = pus_tc_result.unwrap().0;
-        let init_token = self.verif_reporter.add_tc(&pus_tc);
+        let pus_tc = pus_tc_result.unwrap();
+        let init_token = self.verif_reporter.start_verification(&pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
             .verif_reporter
             .acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
             .expect("Acceptance success failure");
-        let service = PusServiceId::try_from(pus_tc.service());
+        let service = PusServiceId::try_from(pus_tc.service_type_id());
         let tc_in_memory: TcInMemory = if let Some(store_addr) = addr_opt {
             PacketInPool::new(sender_id, store_addr).into()
         } else {
@@ -190,6 +188,7 @@ impl PusTcDistributor {
         Ok(HandlingStatus::HandledOne)
     }
 }
+*/
 
 pub trait TargetedPusService {
     const SERVICE_ID: u8;
@@ -272,16 +271,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 +291,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 +301,7 @@ impl<
         VerificationReporter,
         RequestConverter,
         ReplyHandler,
-        ActiveRequestMap,
+        ActiveRequestMapInstance,
         ActiveRequestInfo,
         RequestType,
         ReplyType,
@@ -314,11 +313,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 +511,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,
@@ -534,13 +533,15 @@ pub fn generic_pus_request_timeout_handler(
 pub(crate) mod tests {
     use std::time::Duration;
 
+    use arbitrary_int::{u11, u21};
     use satrs::pus::test_util::TEST_COMPONENT_ID_0;
     use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
     use satrs::request::RequestId;
+    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
         pus::{
             verification::test_util::TestVerificationReporter, ActivePusRequestStd,
-            ActiveRequestMapProvider, MpscTcReceiver,
+            ActiveRequestStore, MpscTcReceiver,
         },
         request::UniqueApidTargetId,
         spacepackets::{
@@ -559,7 +560,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 +574,7 @@ pub(crate) mod tests {
 
     impl<
             ReplyHandler: PusReplyHandler<ActiveRequestInfo, Reply, Error = EcssTmtcError>,
-            ActiveRequestInfo: ActiveRequestProvider,
+            ActiveRequestInfo: ActiveRequest,
             Reply,
         > ReplyHandlerTestbench<ReplyHandler, ActiveRequestInfo, Reply>
     {
@@ -593,17 +594,17 @@ pub(crate) mod tests {
 
         pub fn add_tc(
             &mut self,
-            apid: u16,
-            apid_target: u32,
+            apid: u11,
+            apid_target: u21,
             time_stamp: &[u8],
         ) -> (verification::RequestId, ActivePusRequestStd) {
             let sp_header = SpHeader::new_from_apid(apid);
-            let sec_header_dummy = PusTcSecondaryHeader::new_simple(0, 0);
-            let init = self.verif_reporter.add_tc(&PusTcCreator::new(
+            let sec_header_dummy = PusTcSecondaryHeader::new_simple(MessageTypeId::new(0, 0));
+            let init = self.verif_reporter.start_verification(&PusTcCreator::new(
                 sp_header,
                 sec_header_dummy,
                 &[],
-                true,
+                CreatorConfig::default(),
             ));
             let accepted = self
                 .verif_reporter
@@ -674,7 +675,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 +689,7 @@ pub(crate) mod tests {
 
     impl<
             Converter: PusTcToRequestConverter<ActiveRequestInfo, Request, Error = GenericConversionError>,
-            ActiveRequestInfo: ActiveRequestProvider,
+            ActiveRequestInfo: ActiveRequest,
             Request,
         > PusConverterTestbench<Converter, ActiveRequestInfo, Request>
     {
@@ -706,7 +707,7 @@ pub(crate) mod tests {
         }
 
         pub fn add_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
-            let token = self.verif_reporter.add_tc(tc);
+            let token = self.verif_reporter.start_verification(tc);
             self.current_request_id = Some(verification::RequestId::new(tc));
             self.current_packet = Some(tc.to_vec().unwrap());
             self.verif_reporter
@@ -722,8 +723,8 @@ pub(crate) mod tests {
             &mut self,
             token: VerificationToken<TcStateAccepted>,
             time_stamp: &[u8],
-            expected_apid: u16,
-            expected_apid_target: u32,
+            expected_apid: u11,
+            expected_apid_target: u21,
         ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
             if self.current_packet.is_none() {
                 return Err(GenericConversionError::InvalidAppData(
@@ -734,7 +735,7 @@ pub(crate) mod tests {
             let tc_reader = PusTcReader::new(&current_packet).unwrap();
             let (active_info, request) = self.converter.convert(
                 token,
-                &tc_reader.0,
+                &tc_reader,
                 &self.dummy_sender,
                 &self.verif_reporter,
                 time_stamp,
@@ -754,8 +755,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 +765,7 @@ pub(crate) mod tests {
             TestVerificationReporter,
             RequestConverter,
             ReplyHandler,
-            ActiveRequestMap,
+            ActiveRequestMapInstance,
             ActiveRequestInfo,
             RequestType,
             ReplyType,

satrs-example/src/legacy/pus/mode.rs

@@ -1,6 +1,9 @@
+use arbitrary_int::traits::Integer as _;
+use arbitrary_int::u14;
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
-use satrs_example::config::pus::PUS_MODE_SERVICE;
+use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
+use satrs_example::ids;
 use std::sync::mpsc;
 use std::time::Duration;
 
@@ -8,8 +11,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 +23,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::{
@@ -77,10 +80,19 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
                     .write_to_be_bytes(&mut source_data)
                     .expect("writing mode reply failed");
                 let req_id = verification::RequestId::from(reply.request_id());
-                let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0);
-                let sec_header =
-                    PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
-                let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, true);
+                let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::ZERO, 0);
+                let sec_header = PusTmSecondaryHeader::new(
+                    MessageTypeId::new(200, Subservice::TmModeReply as u8),
+                    0,
+                    0,
+                    time_stamp,
+                );
+                let pus_tm = PusTmCreator::new(
+                    sp_header,
+                    sec_header,
+                    &source_data,
+                    CreatorConfig::default(),
+                );
                 tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?;
                 verification_handler.completion_success(tm_sender, started_token, time_stamp)?;
             }
@@ -146,7 +158,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo
         verif_reporter: &impl VerificationReportingProvider,
         time_stamp: &[u8],
     ) -> Result<(ActivePusRequestStd, ModeRequest), Self::Error> {
-        let subservice = tc.subservice();
+        let subservice = tc.message_subtype_id();
         let user_data = tc.user_data();
         let not_enough_app_data = |expected: usize| {
             verif_reporter
@@ -210,22 +222,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,
     );
@@ -287,8 +302,11 @@ impl TargetedPusService for ModeServiceWrapper {
 
 #[cfg(test)]
 mod tests {
+    use arbitrary_int::traits::Integer;
+    use arbitrary_int::u14;
     use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
     use satrs::request::MessageMetadata;
+    use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use satrs::{
         mode::{ModeAndSubmode, ModeReply, ModeRequest},
         pus::mode::Subservice,
@@ -311,11 +329,12 @@ mod tests {
     fn mode_converter_read_mode_request() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
-        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sec_header =
+            PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcReadMode as u8));
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -327,15 +346,16 @@ mod tests {
     fn mode_converter_set_mode_request() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
-        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sec_header =
+            PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcSetMode as u8));
         let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN];
         let mode_and_submode = ModeAndSubmode::new(2, 1);
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
         mode_and_submode
             .write_to_be_bytes(&mut app_data[4..])
             .unwrap();
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -353,11 +373,14 @@ mod tests {
     fn mode_converter_announce_mode() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
-        let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
+            200,
+            Subservice::TcAnnounceMode as u8,
+        ));
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -369,12 +392,14 @@ mod tests {
     fn mode_converter_announce_mode_recursively() {
         let mut testbench =
             PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
-        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0);
-        let sec_header =
-            PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8);
+        let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
+            200,
+            Subservice::TcAnnounceModeRecursive as u8,
+        ));
         let mut app_data: [u8; 4] = [0; 4];
-        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
-        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true);
+        app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
+        let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
         let token = testbench.add_tc(&tc);
         let (_active_req, req) = testbench
             .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -390,7 +415,7 @@ mod tests {
         );
         let mode_reply = ModeReply::ModeReply(ModeAndSubmode::new(5, 1));
         let unrequested_reply =
-            GenericMessage::new(MessageMetadata::new(10_u32, 15_u64), mode_reply);
+            GenericMessage::new(MessageMetadata::new(10_u32, 15_u32), mode_reply);
         // Right now this function does not do a lot. We simply check that it does not panic or do
         // weird stuff.
         let result = testbench.handle_unrequested_reply(&unrequested_reply);

satrs-example/src/legacy/pus/scheduler.rs

@@ -5,17 +5,17 @@ use crate::pus::create_verification_reporter;
 use crate::tmtc::sender::TmTcSender;
 use log::info;
 use satrs::pool::{PoolProvider, StaticMemoryPool};
-use satrs::pus::scheduler::{PusScheduler, TcInfo};
+use satrs::pus::scheduler::{PusSchedulerAlloc, 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,9 +84,9 @@ pub struct SchedulingServiceWrapper {
     pub pus_11_handler: PusSchedServiceHandler<
         MpscTcReceiver,
         TmTcSender,
-        EcssTcInMemConverter,
+        EcssTcCacher,
         VerificationReporter,
-        PusScheduler,
+        PusSchedulerAlloc,
     >,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
@@ -174,19 +174,19 @@ 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,
 ) -> SchedulingServiceWrapper {
-    let scheduler = PusScheduler::new_with_current_init_time(Duration::from_secs(5))
+    let scheduler = PusSchedulerAlloc::new_with_current_init_time(Duration::from_secs(5))
         .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,

satrs-example/src/legacy/pus/test.rs

@@ -1,33 +1,33 @@
 use crate::pus::create_verification_reporter;
 use crate::tmtc::sender::TmTcSender;
 use log::info;
-use satrs::event_man::{EventMessage, EventMessageU32};
+use satrs::event_man_legacy::{EventMessage, EventMessageU32};
 use satrs::pus::test::PusService17TestHandler;
 use satrs::pus::verification::{FailParams, VerificationReporter, VerificationReportingProvider};
 use satrs::pus::PartialPusHandlingError;
 use satrs::pus::{
-    DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcInMemConversionProvider,
-    EcssTcInMemConverter, MpscTcReceiver, PusServiceHelper,
+    CacheAndReadRawEcssTc, DirectPusPacketHandlerResult, EcssTcAndToken, EcssTcCacher,
+    MpscTcReceiver, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs_example::config::pus::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
+use satrs_example::ids::generic_pus::PUS_TEST;
 use std::sync::mpsc;
 
 use super::{DirectPusService, HandlingStatus};
 
 pub fn create_test_service(
     tm_sender: TmTcSender,
-    tc_in_mem_converter: EcssTcInMemConverter,
+    tc_in_mem_converter: EcssTcCacher,
     event_sender: mpsc::SyncSender<EventMessageU32>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
 ) -> TestCustomServiceWrapper {
     let pus17_handler = PusService17TestHandler::new(PusServiceHelper::new(
-        PUS_TEST_SERVICE.id(),
+        PUS_TEST.id(),
         pus_test_rx,
         tm_sender,
-        create_verification_reporter(PUS_TEST_SERVICE.id(), PUS_TEST_SERVICE.apid),
+        create_verification_reporter(PUS_TEST.id(), PUS_TEST.apid),
         tc_in_mem_converter,
     ));
     TestCustomServiceWrapper {
@@ -37,12 +37,8 @@ pub fn create_test_service(
 }
 
 pub struct TestCustomServiceWrapper {
-    pub handler: PusService17TestHandler<
-        MpscTcReceiver,
-        TmTcSender,
-        EcssTcInMemConverter,
-        VerificationReporter,
-    >,
+    pub handler:
+        PusService17TestHandler<MpscTcReceiver, TmTcSender, EcssTcCacher, VerificationReporter>,
     pub event_tx: mpsc::SyncSender<EventMessageU32>,
 }
 
@@ -90,7 +86,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                 );
             }
             DirectPusPacketHandlerResult::CustomSubservice(subservice, token) => {
-                let (tc, _) = PusTcReader::new(
+                let tc = PusTcReader::new(
                     self.handler
                         .service_helper
                         .tc_in_mem_converter
@@ -100,7 +96,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                 if subservice == 128 {
                     info!("generating test event");
                     self.event_tx
-                        .send(EventMessage::new(PUS_TEST_SERVICE.id(), TEST_EVENT.into()))
+                        .send(EventMessage::new(PUS_TEST.id(), TEST_EVENT.into()))
                         .expect("Sending test event failed");
                     match self.handler.service_helper.verif_reporter().start_success(
                         self.handler.service_helper.tm_sender(),
@@ -126,7 +122,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                         }
                     }
                 } else {
-                    let fail_data = [tc.subservice()];
+                    let fail_data = [tc.message_subtype_id()];
                     self.handler
                         .service_helper
                         .verif_reporter()

satrs-example/src/legacy/requests.rs

@@ -8,15 +8,15 @@ 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;
 
+/*
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum CompositeRequest {
@@ -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),
@@ -55,7 +55,7 @@ impl GenericRequestRouter {
     ) {
         warn!(
             "Routing request for service {} failed: {error:?}",
-            tc.service()
+            tc.service_type_id()
         );
         let accepted_token: VerificationToken<TcStateAccepted> = active_request
             .token()
@@ -66,7 +66,8 @@ impl GenericRequestRouter {
                 let apid_target_id = UniqueApidTargetId::from(id);
                 warn!("Target APID for request: {}", apid_target_id.apid);
                 warn!("Target Unique ID for request: {}", apid_target_id.unique_id);
-                let mut fail_data: [u8; 8] = [0; 8];
+                let mut fail_data: [u8; core::mem::size_of::<ComponentId>()] =
+                    [0; core::mem::size_of::<ComponentId>()];
                 fail_data.copy_from_slice(&id.to_be_bytes());
                 verif_reporter
                     .completion_failure(
@@ -152,3 +153,4 @@ impl PusRequestRouter<ModeRequest> for GenericRequestRouter {
         Err(GenericRoutingError::UnknownTargetId(target_id))
     }
 }
+*/

satrs-example/src/lib.rs

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

satrs-example/src/logger.rs

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

satrs-example/src/main.rs

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

satrs-example/src/spi.rs

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