Merge pull request 'ran cargo update' (#270) from dep-update into main

Reviewed-on: #270

.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
 
@@ -57,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
-      - run: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc -p satrs --all-features
+      - run: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc -p satrs --all-features --no-deps
 
   clippy:
     name: Clippy
@@ -67,4 +71,5 @@ jobs:
       - 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,9 +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 = [

embedded-examples/embedded-client/Cargo.toml

@@ -10,8 +10,10 @@ toml = "0.9"
 serde = { version = "1", features = ["derive"] }
 satrs-stm32f3-disco-rtic = { path = "../stm32f3-disco-rtic" }
 spacepackets = { version = "0.17" }
-tmtc-utils = { git = "https://egit.irs.uni-stuttgart.de/rust/tmtc-utils.git", version = "0.1" }
+embedded-models = { path = "../models" }
+tmtc-utils = { git = "https://egit.irs.uni-stuttgart.de/rust/tmtc-utils.git", version = "0.1", rev = "d8015379a45e77400dd9c71afbf22ca415ed67d1" }
 postcard = { version = "1", features = ["alloc"] }
+anyhow = "1"
 cobs = "0.5"
 fern = "0.7"
 humantime = "2"

embedded-examples/embedded-client/config.toml

@@ -1,2 +1,3 @@
 [interface]
 serial_port = "/dev/ttyUSB0"
+# udp_addr = "192.168.XXX.XX:7301"

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

@@ -1,13 +1,10 @@
-use std::{
-    fs::File,
-    io::Read,
-    path::Path,
-    time::{Duration, SystemTime},
-};
+use std::time::Duration;
 
+use anyhow::bail;
 use clap::Parser;
 use cobs::CobsDecoderOwned;
-use satrs_stm32f3_disco_rtic::Request;
+use embedded_client::setup_logger;
+use embedded_models::stm32f3;
 use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
 use tmtc_utils::transport::serial::PacketTransportSerialCobs;
 
@@ -21,56 +18,23 @@ struct Cli {
     set_led_frequency: Option<u32>,
 }
 
-#[derive(Debug, serde::Deserialize)]
-struct Config {
-    interface: Interface,
-}
-
-#[derive(Debug, serde::Deserialize)]
-struct Interface {
-    serial_port: String,
-}
-
-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(())
-}
-
-fn main() {
+fn main() -> anyhow::Result<()> {
     setup_logger().expect("failed to initialize logger");
-    println!("sat-rs embedded examples TMTC client");
-
+    println!("-- STM32F3 TMTC client --");
     let cli = Cli::parse();
-    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);
+    let config = embedded_client::Config::new_from_file();
 
-    let serial = serialport::new(config.interface.serial_port, 115200)
+    if config.interface.serial_port.is_none() {
+        bail!("Serial port not specified in configuration file.");
+    }
+    let serial_port = config.interface.serial_port.as_ref().unwrap();
+    let serial = serialport::new(serial_port, 115200)
         .open()
         .expect("opening serial port failed");
     let mut transport = PacketTransportSerialCobs::new(serial, CobsDecoderOwned::new(1024));
 
     if cli.ping {
-        let request = Request::Ping;
-        let tc = create_stm32f3_tc(&request);
+        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()
@@ -79,7 +43,7 @@ fn main() {
     }
 
     if let Some(freq_ms) = cli.set_led_frequency {
-        let request = Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        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}",
@@ -100,7 +64,7 @@ fn main() {
     }
 }
 
-fn create_stm32f3_tc(request: &Request) -> CcsdsPacketCreatorOwned {
+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,95 @@
+use std::{net::UdpSocket, time::Duration};
+
+use anyhow::{Context as _, bail};
+use clap::Parser;
+use embedded_client::setup_logger;
+use embedded_models::{TmHeader, stm32h7};
+use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
+use tmtc_utils::transport::udp::PacketTransportUdp;
+
+#[derive(Parser, Debug)]
+struct Cli {
+    #[arg(short, long)]
+    ping: bool,
+
+    /// Set frequency in milliseconds.
+    #[arg(short, long)]
+    set_led_frequency: Option<u32>,
+
+    /// UDP address to bind to.
+    #[arg(short, long)]
+    udp_addr: Option<std::net::SocketAddr>,
+}
+
+fn main() -> anyhow::Result<()> {
+    setup_logger().expect("failed to initialize logger");
+    println!("-- STM32H7 TMTC client --");
+    let cli = Cli::parse();
+    let config = embedded_client::Config::new_from_file();
+    let mut udp_addr = cli.udp_addr;
+    if udp_addr.is_none() {
+        udp_addr = config.interface.udp_addr;
+    }
+    if udp_addr.is_none() {
+        bail!("UDP address not specified in config.toml or via command line");
+    }
+    let udp_addr = udp_addr.unwrap();
+    log::info!("binding to UDP address: {}", udp_addr);
+    let local_socket = UdpSocket::bind("0.0.0.0:0").expect("failed to bind UDP socket");
+    let mut transport = PacketTransportUdp::new(local_socket, udp_addr)
+        .with_context(|| "crateing UDP transport failed")?;
+
+    if cli.ping {
+        let tc = create_stm32h7_tc(&embedded_models::stm32h7::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 = stm32h7::Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        let tc = create_stm32h7_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::debug!("Received packet: {:?}", reader);
+                if let Ok(reader) = reader {
+                    let packet_data = reader.packet_data();
+                    let tm_header = postcard::take_from_bytes::<TmHeader>(packet_data);
+                    if let Ok((tm_header, remainder)) = tm_header {
+                        let response = postcard::from_bytes::<stm32h7::Response>(remainder);
+                        if let Ok(response) = response {
+                            log::info!(
+                                "Received TM with header: {:?} and response: {:?}",
+                                tm_header,
+                                response
+                            );
+                        } else {
+                            log::error!("Failed to deserialize response: {:?}", response.err());
+                        }
+                    } else {
+                        log::error!("Failed to deserialize TM header: {:?}", tm_header.err());
+                    }
+                }
+            })
+            .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,43 @@
+use std::{fs::File, io::Read as _, net::SocketAddr, path::Path, time::SystemTime};
+
+#[derive(Debug, serde::Deserialize)]
+pub struct Config {
+    pub interface: Interface,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct Interface {
+    pub serial_port: Option<String>,
+    pub udp_addr: Option<SocketAddr>,
+}
+
+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");
+        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::Info)
+        .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.toml

@@ -7,6 +7,7 @@ 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 = "1"
@@ -14,9 +15,11 @@ 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"] }
+embassy-stm32 = { version = "0.6", features = ["defmt", "stm32f303vc", "memory-x", "unstable-pac", "time-driver-any"] }
+embassy-time = { version = "0.5", features = ["defmt", "generic-queue-16", "defmt-timestamp-uptime-ms"]}
 enumset = "1"
 heapless = "0.9"
+embassy-sync = "0.8"
 spacepackets = { version = "0.17", default-features = false, features = ["defmt", "serde"] }
 static_cell = "2"
 cobs = { version = "0.5", default-features = false, features = ["defmt"] }
@@ -27,15 +30,9 @@ serde = { version = "1", default-features = false, features = ["derive"] }
 
 rtic = { version = "2", features = ["thumbv7-backend"] }
 rtic-sync = { version = "1" }
-rtic-monotonics = { version = "2", features = ["cortex-m-systick"] }
-
-#[dependencies.satrs]
-# path = "../../satrs"
-#default-features = false
-# features = ["defmt"]
 
 [dev-dependencies]
-defmt-test = "0.4"
+defmt-test = "0.5"
 
 # cargo test
 [profile.test]

embedded-examples/stm32f3-disco-rtic/memory.x

@@ -1,33 +0,0 @@
-/* Linker script for the STM32F303VCT6 */
-MEMORY
-{
-  /* NOTE 1 K = 1 KiBi = 1024 bytes */
-  FLASH : ORIGIN = 0x08000000, LENGTH = 256K
-  RAM : ORIGIN = 0x20000000, LENGTH = 40K
-}
-
-/* This is where the call stack will be allocated. */
-/* The stack is of the full descending type. */
-/* You may want to use this variable to locate the call stack and static
-   variables in different memory regions. Below is shown the default value */
-/* _stack_start = ORIGIN(RAM) + LENGTH(RAM); */
-
-/* You can use this symbol to customize the location of the .text section */
-/* If omitted the .text section will be placed right after the .vector_table
-   section */
-/* This is required only on microcontrollers that store some configuration right
-   after the vector table */
-/* _stext = ORIGIN(FLASH) + 0x400; */
-
-/* Example of putting non-initialized variables into custom RAM locations. */
-/* This assumes you have defined a region RAM2 above, and in the Rust
-   sources added the attribute `#[link_section = ".ram2bss"]` to the data
-   you want to place there. */
-/* Note that the section will not be zero-initialized by the runtime! */
-/* SECTIONS {
-     .ram2bss (NOLOAD) : ALIGN(4) {
-       *(.ram2bss);
-       . = ALIGN(4);
-     } > RAM2
-   } INSERT AFTER .bss;
-*/

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

@@ -6,12 +6,9 @@ use rtic::app;
 
 #[app(device = embassy_stm32)]
 mod app {
-    use rtic_monotonics::fugit::ExtU32;
-    use rtic_monotonics::Monotonic as _;
+    use embassy_time::Timer;
     use satrs_stm32f3_disco_rtic::{Direction, LedPinSet, Leds};
 
-    rtic_monotonics::systick_monotonic!(Mono, 1000);
-
     #[shared]
     struct Shared {}
 
@@ -22,7 +19,7 @@ mod app {
     }
 
     #[init]
-    fn init(cx: init::Context) -> (Shared, Local) {
+    fn init(_cx: init::Context) -> (Shared, Local) {
         let p = embassy_stm32::init(Default::default());
 
         defmt::info!("Starting sat-rs demo application for the STM32F3-Discovery using RTICv2");
@@ -39,8 +36,6 @@ mod app {
         };
         let leds = Leds::new(led_pin_set);
 
-        // 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 {},
@@ -55,7 +50,7 @@ mod app {
     async fn blinky(cx: blinky::Context) {
         loop {
             cx.local.leds.blink_next(cx.local.current_dir);
-            Mono::delay(200.millis()).await;
+            Timer::after_millis(200).await;
         }
     }
 }

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

@@ -1,13 +1,11 @@
 #![no_main]
 #![no_std]
 
+use defmt_rtt as _;
+use panic_probe as _;
+
 use arbitrary_int::u11;
-use core::time::Duration;
 use embassy_stm32::gpio::Output;
-use spacepackets::{
-    ccsds_packet_len_for_user_data_len_with_checksum, CcsdsPacketCreationError,
-    CcsdsPacketCreatorWithReservedData, CcsdsPacketIdAndPsc, SpacePacketHeader,
-};
 
 pub const APID: u11 = u11::new(0x02);
 
@@ -40,49 +38,6 @@ impl Direction {
     }
 }
 
-#[derive(Copy, Clone, Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub enum Request {
-    Ping,
-    ChangeBlinkFrequency(Duration),
-}
-
-#[derive(Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub struct TmHeader {
-    pub tc_packet_id: Option<CcsdsPacketIdAndPsc>,
-    pub uptime_millis: u32,
-}
-
-#[derive(Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
-pub enum Response {
-    CommandDone,
-}
-
-pub fn tm_size(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(
-    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())
-}
-
 pub struct Leds {
     pub north: Output<'static>,
     pub north_east: Output<'static>,

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

@@ -1,30 +1,21 @@
 #![no_std]
 #![no_main]
-use arbitrary_int::{u11, u14};
+use arbitrary_int::u14;
 use cortex_m_semihosting::debug::{self, EXIT_FAILURE, EXIT_SUCCESS};
-use satrs_stm32f3_disco_rtic::{create_tm_packet, tm_size, CcsdsPacketId, Request, Response};
-use spacepackets::{CcsdsPacketCreationError, SpHeader};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+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;
 
-#[allow(unused_imports)]
-use rtic_monotonics::fugit::{MillisDurationU32, TimerInstantU32};
-use rtic_monotonics::systick::prelude::*;
-
-use crate::app::Mono;
-
 const UART_BAUD: u32 = 115200;
 const DEFAULT_BLINK_FREQ_MS: u32 = 1000;
-const TX_HANDLER_FREQ_MS: u32 = 20;
 const MAX_TC_LEN: usize = 128;
 const MAX_TM_LEN: usize = 128;
 
-pub const PUS_APID: u11 = u11::new(0x02);
-
 // This is the predictable maximum overhead of the COBS encoding scheme.
 // It is simply the maximum packet lenght dividied by 254 rounded up.
 const COBS_TM_OVERHEAD: usize = cobs::max_encoding_overhead(MAX_TM_LEN);
@@ -35,7 +26,8 @@ const TC_DMA_BUF_LEN: usize = 512;
 
 type TmPacket = heapless::Vec<u8, MAX_TM_LEN>;
 
-static TM_QUEUE: heapless::mpmc::Queue<TmPacket, 16> = heapless::mpmc::Queue::new();
+static TM_QUEUE: embassy_sync::channel::Channel<CriticalSectionRawMutex, TmPacket, 16> =
+    embassy_sync::channel::Channel::new();
 
 #[derive(Debug, defmt::Format, thiserror::Error)]
 pub enum TmSendError {
@@ -47,8 +39,8 @@ pub enum TmSendError {
 
 #[derive(Debug, defmt::Format)]
 pub struct RequestWithTcId {
-    pub request: Request,
-    pub tc_id: CcsdsPacketId,
+    pub request: stm32f3::Request,
+    pub tc_id: CcsdsPacketIdAndPsc,
 }
 
 #[app(device = embassy_stm32)]
@@ -57,18 +49,20 @@ mod app {
 
     use super::*;
     use arbitrary_int::u14;
+    use embassy_time::Timer;
+    use embedded_models::stm32f3::{Request, Response};
     use rtic::Mutex;
     use rtic_sync::{
         channel::{Receiver, Sender},
         make_channel,
     };
-    use satrs_stm32f3_disco_rtic::{CcsdsPacketId, LedPinSet, Request, Response};
+    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>;
+        DMA1_CHANNEL6 => embassy_stm32::dma::InterruptHandler<embassy_stm32::peripherals::DMA1_CH6>;
+        DMA1_CHANNEL7 => embassy_stm32::dma::InterruptHandler<embassy_stm32::peripherals::DMA1_CH7>;
     });
 
     #[shared]
@@ -86,15 +80,13 @@ mod app {
     }
 
     #[init]
-    fn init(cx: init::Context) -> (Shared, Local) {
+    fn init(_cx: init::Context) -> (Shared, Local) {
         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);
 
         defmt::info!("sat-rs demo application for the STM32F3-Discovery with RTICv2");
         let led_pin_set = LedPinSet {
@@ -112,7 +104,7 @@ mod app {
         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,
+            p.USART2, p.PA3, p.PA2, p.DMA1_CH7, p.DMA1_CH6, Irqs, config,
         )
         .unwrap();
 
@@ -142,10 +134,7 @@ mod app {
         loop {
             cx.local.leds.blink_next(cx.local.current_dir);
             let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
-            Mono::delay(MillisDurationU32::from_ticks(
-                current_blink_freq.as_millis() as u32,
-            ))
-            .await;
+            Timer::after_millis(current_blink_freq.as_millis() as u64).await;
         }
     }
 
@@ -158,7 +147,8 @@ mod app {
     )]
     async fn serial_tx_handler(cx: serial_tx_handler::Context) {
         loop {
-            while let Some(vec) = TM_QUEUE.dequeue() {
+            loop {
+                let vec = TM_QUEUE.receive().await;
                 let encoded_len =
                     cobs::encode_including_sentinels(&vec[0..vec.len()], cx.local.encoded_buf);
                 defmt::debug!("sending {} bytes over UART", encoded_len);
@@ -167,9 +157,7 @@ mod app {
                     .write(&cx.local.encoded_buf[0..encoded_len])
                     .await
                     .unwrap();
-                continue;
             }
-            Mono::delay(TX_HANDLER_FREQ_MS.millis()).await;
         }
     }
 
@@ -198,9 +186,8 @@ mod app {
                                     &decoder.dest()[0..packet_size],
                                 ) {
                                     Ok(packet) => {
-                                        let packet_id = packet.packet_id();
-                                        let psc = packet.psc();
-                                        let tc_packet_id = CcsdsPacketId { packet_id, psc };
+                                        let tc_packet_id =
+                                            CcsdsPacketIdAndPsc::new_from_ccsds_packet(&packet);
                                         if let Ok(request) =
                                             postcard::from_bytes::<Request>(packet.packet_data())
                                         {
@@ -240,13 +227,16 @@ mod app {
             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::Ping => {
+                            handle_ping_request(&mut cx, request_with_tc_id.tc_id).await
+                        }
                         Request::ChangeBlinkFrequency(duration) => {
                             handle_change_blink_frequency_request(
                                 &mut cx,
                                 request_with_tc_id.tc_id,
                                 duration,
                             )
+                            .await
                         }
                     };
                     if let Err(e) = tm_send_result {
@@ -258,19 +248,19 @@ mod app {
         }
     }
 
-    fn handle_ping_request(
-        cx: &mut req_handler::Context,
-        tc_packet_id: CcsdsPacketId,
+    async 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::CommandDone, *cx.local.seq_count)?;
+        send_tm(tc_packet_id, Response::Ok, *cx.local.seq_count).await?;
         *cx.local.seq_count = cx.local.seq_count.wrapping_add(u14::new(1));
         Ok(())
     }
 
-    fn handle_change_blink_frequency_request(
-        cx: &mut req_handler::Context,
-        tc_packet_id: CcsdsPacketId,
+    async fn handle_change_blink_frequency_request(
+        cx: &mut req_handler::Context<'_>,
+        tc_packet_id: CcsdsPacketIdAndPsc,
         duration: Duration,
     ) -> Result<(), TmSendError> {
         defmt::info!(
@@ -280,30 +270,27 @@ mod app {
         cx.shared
             .blink_freq
             .lock(|blink_freq| *blink_freq = duration);
-        send_tm(tc_packet_id, Response::CommandDone, *cx.local.seq_count)?;
+        send_tm(tc_packet_id, Response::Ok, *cx.local.seq_count).await?;
         *cx.local.seq_count = cx.local.seq_count.wrapping_add(u14::new(1));
         Ok(())
     }
 }
 
-fn send_tm(
-    tc_packet_id: CcsdsPacketId,
-    response: Response,
+async fn send_tm(
+    tc_packet_id: CcsdsPacketIdAndPsc,
+    response: stm32f3::Response,
     current_seq_count: u14,
 ) -> Result<(), TmSendError> {
-    let sp_header = SpHeader::new_for_unseg_tc(PUS_APID, current_seq_count, 0);
-    let tm_header = satrs_stm32f3_disco_rtic::TmHeader {
+    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(),
+        uptime_millis: embassy_time::Instant::now().as_millis(),
     };
     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);
-    }
+    TM_QUEUE.send(tm_packet).await;
     Ok(())
 }
 

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,38 +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 = "1"
-defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
+defmt-rtt = "1"
 panic-probe = { version = "1", features = ["print-defmt"] }
-cortex-m-semihosting = "0.5.0"
-# TODO: Replace with embassy-hal.
-stm32h7xx-hal = { version="0.16", features= ["stm32h743v", "ethernet"] }
-embedded-alloc = "0.6"
-rtic-sync = { version = "1", features = ["defmt-03"] }
+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.12"
-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.4"
+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,164 @@ 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 => {
+                                defmt::info!("Received Ping request");
+                                stm32h7::Response::Ok
+                            }
+                            stm32h7::Request::ChangeBlinkFrequency(duration) => {
+                                defmt::info!(
+                                    "Received blinky frequency change request: {} ms",
+                                    duration.as_millis()
+                                );
+                                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
-            }
-        },
-
-    ]
-}

justfile

@@ -11,15 +11,23 @@ test:
   cargo nextest run --all-features
   cargo test --doc --all-features
 
-embedded:
+embedded: embedded-stm32h7 embedded-stm32f3
   cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
 
-fmt:
-  cargo fmt --all
+[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
 

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,28 +18,24 @@ csv = "1"
 num_enum = "0.7"
 thiserror = "2"
 lazy_static = "1"
-strum = { version = "0.27", features = ["derive"] }
+strum = { version = "0.28", features = ["derive"] }
 derive-new = "0.7"
 cfg-if = "1"
 arbitrary-int = "2"
-bitbybit = "1.4"
+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]
-default = ["heap_tmtc"]
-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.27", 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/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/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,87 +0,0 @@
-use arbitrary_int::u11;
-use satrs::pus::verification::RequestId;
-use satrs::spacepackets::ecss::tc::PusTcCreator;
-use satrs::spacepackets::ecss::tm::PusTmReader;
-use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
-use satrs::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(u11::new(0x02)),
-        MessageTypeId::new(17, 1),
-        &[],
-        CreatorConfig::default(),
-    );
-    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 = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
-                if pus_tm.service_type_id() == 17 && pus_tm.message_subtype_id() == 2 {
-                    println!("Received PUS Ping Reply TM[17,2]")
-                } else if pus_tm.service_type_id() == 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();
-                    let subtype_id = pus_tm.message_subtype_id();
-                    if subtype_id == 1 {
-                        println!("Received TM[1,1] acceptance success for request ID {req_id}")
-                    } else if subtype_id == 2 {
-                        println!("Received TM[1,2] acceptance failure for request ID {req_id}")
-                    } else if subtype_id == 3 {
-                        println!("Received TM[1,3] start success for request ID {req_id}")
-                    } else if subtype_id == 4 {
-                        println!("Received TM[1,2] start failure for request ID {req_id}")
-                    } else if subtype_id == 5 {
-                        println!("Received TM[1,5] step success for request ID {req_id}")
-                    } else if subtype_id == 6 {
-                        println!("Received TM[1,6] step failure for request ID {req_id}")
-                    } else if subtype_id == 7 {
-                        println!("Received TM[1,7] completion success for request ID {req_id}")
-                    } else if subtype_id == 8 {
-                        println!("Received TM[1,8] completion failure for request ID {req_id}");
-                    }
-                } else {
-                    println!(
-                        "Received TM[{}, {}] with {} bytes",
-                        pus_tm.service_type_id(),
-                        pus_tm.message_subtype_id(),
-                        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

@@ -7,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_legacy::{EventU32TypedSev, SeverityInfo},
-    pool::{StaticMemoryPool, StaticPoolConfig},
-};
+use satrs::pool::{StaticMemoryPool, StaticPoolConfig};
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, TryFromPrimitive, IntoPrimitive)]
 #[repr(u8)]
@@ -39,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 crate::ids::Apid::iter() {
+        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 crate::ids::Apid::iter() {
+        for id in models::Apid::iter() {
             set.insert(id as u16);
         }
         set
@@ -174,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,43 +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,
-    ids::{eps::PCDU, generic_pus::PUS_MODE},
-    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;
@@ -194,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();
                 }
             }
@@ -246,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);
+            }
         }
     }
 
@@ -326,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?
@@ -356,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 => {
@@ -406,115 +526,33 @@ impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
     }
 }
 
-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.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.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.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::u21;
-    use satrs::{
-        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
+    use arbitrary_int::u11;
+    use models::{
+        Apid, TcHeader,
+        pcdu::{SwitchMapBinary, SwitchStateBinary},
+    };
+    use satrs::{
+        mode::{ModeReply, ModeRequest},
+        request::{GenericMessage, MessageMetadata},
+        spacepackets::SpacePacketHeader,
     };
-    use satrs_example::ids::{self, Apid};
-    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,
@@ -550,47 +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.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.raw_value(), u21::new(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(ids::eps::SUBSYSTEM.into(), mode_reply_tx_to_parent);
-            handler.add_mode_parent(PUS_MODE.into(), mode_reply_tx_to_pus);
             Self {
                 mode_request_tx,
-                mode_reply_rx_to_pus,
                 mode_reply_rx_to_parent,
-                composite_request_tx,
-                hk_reply_rx,
+                tc_tx,
                 tm_rx,
                 switch_request_tx,
                 handler,
@@ -610,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.
@@ -651,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
@@ -666,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.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);
@@ -712,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.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, ids::acs::MGM0.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);
@@ -733,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/ids.rs

@@ -1,109 +0,0 @@
-//! This is an auto-generated configuration module.
-use satrs::request::UniqueApidTargetId;
-
-#[derive(Debug, PartialEq, Eq, strum::EnumIter)]
-#[bitbybit::bitenum(u11)]
-pub enum Apid {
-    Sched = 1,
-    GenericPus = 2,
-    Acs = 3,
-    Cfdp = 4,
-    Tmtc = 5,
-    Eps = 6,
-}
-
-pub mod acs {
-
-    #[derive(Debug, PartialEq, Eq)]
-    #[bitbybit::bitenum(u21, exhaustive = false)]
-    pub enum Id {
-        Subsystem = 1,
-        Assembly = 2,
-        Mgm0 = 3,
-        Mgm1 = 4,
-    }
-
-    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Subsystem.raw_value());
-    pub const ASSEMBLY: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Assembly.raw_value());
-    pub const MGM0: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm0.raw_value());
-    pub const MGM1: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm1.raw_value());
-}
-
-pub mod eps {
-    #[derive(Debug, PartialEq, Eq)]
-    #[bitbybit::bitenum(u21, exhaustive = false)]
-    pub enum Id {
-        Pcdu = 0,
-        Subsystem = 1,
-    }
-
-    pub const PCDU: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Pcdu.raw_value());
-    pub const SUBSYSTEM: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Subsystem.raw_value());
-}
-
-pub mod generic_pus {
-    #[derive(Debug, PartialEq, Eq)]
-    #[bitbybit::bitenum(u21, exhaustive = false)]
-    pub enum Id {
-        PusEventManagement = 0,
-        PusRouting = 1,
-        PusTest = 2,
-        PusAction = 3,
-        PusMode = 4,
-        PusHk = 5,
-    }
-
-    pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus.raw_value(),
-        Id::PusEventManagement.raw_value(),
-    );
-    pub const PUS_ROUTING: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus.raw_value(),
-        Id::PusRouting.raw_value(),
-    );
-    pub const PUS_TEST: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus.raw_value(),
-        Id::PusTest.raw_value(),
-    );
-    pub const PUS_ACTION: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus.raw_value(),
-        Id::PusAction.raw_value(),
-    );
-    pub const PUS_MODE: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
-        super::Apid::GenericPus.raw_value(),
-        Id::PusMode.raw_value(),
-    );
-    pub const PUS_HK: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusHk.raw_value());
-}
-
-pub mod sched {
-    #[derive(Debug, PartialEq, Eq)]
-    #[bitbybit::bitenum(u21, exhaustive = false)]
-    pub enum Id {
-        PusSched = 0,
-    }
-
-    pub const PUS_SCHED: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Sched.raw_value(), Id::PusSched.raw_value());
-}
-
-pub mod tmtc {
-    #[derive(Debug, PartialEq, Eq)]
-    #[bitbybit::bitenum(u21, exhaustive = false)]
-    pub enum Id {
-        UdpServer = 0,
-        TcpServer = 1,
-    }
-
-    pub const UDP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::UdpServer.raw_value());
-    pub const TCP_SERVER: super::UniqueApidTargetId =
-        super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::TcpServer.raw_value());
-}

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};
 
@@ -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

@@ -129,15 +129,13 @@ impl TcpTask {
     }
 
     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,66 +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::queue::GenericSendError;
-use satrs::tmtc::PacketAsVec;
-
-use satrs::pool::{PoolProviderWithGuards, SharedStaticMemoryPool};
-use satrs::tmtc::PacketInPool;
 
 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}")
             }
@@ -68,12 +31,49 @@ impl UdpTmHandler for DynamicUdpTmHandler {
     }
 }
 
-pub struct UdpTmtcServer<TmHandler: UdpTmHandler> {
-    pub udp_tc_server: UdpTcServer<TmTcSender, GenericSendError>,
-    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 {
@@ -107,43 +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::OBSW_SERVER_ADDR;
-    use satrs_example::ids;
 
-    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);
@@ -154,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
@@ -179,9 +164,9 @@ 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(ids::Apid::GenericPus.raw_value(), u14::ZERO, 0);
+        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),

satrs-example/src/legacy/events.rs

@@ -1,6 +1,3 @@
-use std::sync::mpsc::{self};
-
-use crate::pus::create_verification_reporter;
 use arbitrary_int::traits::Integer as _;
 use arbitrary_int::u11;
 use satrs::event_man_legacy::{EventMessageU32, EventRoutingError};
@@ -34,6 +31,7 @@ impl EventTmHook for EventApidSetter {
     }
 }
 
+/*
 /// 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> {
@@ -292,3 +290,4 @@ mod tests {
         // TODO: Add test.
     }
 }
+*/

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

@@ -39,6 +39,7 @@ pub fn create_verification_reporter(owner_id: ComponentId, apid: Apid) -> Verifi
     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>,
@@ -187,6 +188,7 @@ impl PusTcDistributor {
         Ok(HandlingStatus::HandledOne)
     }
 }
+*/
 
 pub trait TargetedPusService {
     const SERVICE_ID: u8;

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

@@ -5,7 +5,7 @@ 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::{
@@ -86,7 +86,7 @@ pub struct SchedulingServiceWrapper {
         TmTcSender,
         EcssTcCacher,
         VerificationReporter,
-        PusScheduler,
+        PusSchedulerAlloc,
     >,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
@@ -179,7 +179,7 @@ pub fn create_scheduler_service(
     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(

satrs-example/src/legacy/requests.rs

@@ -15,8 +15,8 @@ use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
 use satrs_example::config::tmtc_err;
-use satrs_example::ids;
 
+/*
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum CompositeRequest {
@@ -153,3 +153,4 @@ impl PusRequestRouter<ModeRequest> for GenericRequestRouter {
         Err(GenericRoutingError::UnknownTargetId(target_id))
     }
 }
+*/

satrs-example/src/lib.rs

@@ -1,13 +1,28 @@
-use satrs::spacepackets::time::cds::CdsTime;
+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;
-pub mod ids;
 
-#[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 {
@@ -38,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;
+        }
+