continue with subsystem

Cargo.toml

@@ -9,7 +9,6 @@ members = [
     "satrs-example/minisim",
     "satrs-shared",
     "embedded-examples/embedded-client",
-    "embedded-examples/models",
 ]
 
 exclude = [

embedded-examples/embedded-client/Cargo.toml

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

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

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

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

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

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

@@ -1,9 +1,13 @@
-use std::time::Duration;
+use std::{
+    fs::File,
+    io::Read,
+    path::Path,
+    time::{Duration, SystemTime},
+};
 
 use clap::Parser;
 use cobs::CobsDecoderOwned;
-use embedded_client::setup_logger;
-use embedded_models::stm32f3;
+use satrs_stm32f3_disco_rtic::Request;
 use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
 use tmtc_utils::transport::serial::PacketTransportSerialCobs;
 
@@ -17,11 +21,47 @@ 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() {
     setup_logger().expect("failed to initialize logger");
-    println!("-- STM32F3 TMTC client --");
+    println!("sat-rs embedded examples TMTC client");
+
     let cli = Cli::parse();
-    let config = embedded_client::Config::new_from_file();
+    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 serial = serialport::new(config.interface.serial_port, 115200)
         .open()
@@ -29,7 +69,8 @@ fn main() {
     let mut transport = PacketTransportSerialCobs::new(serial, CobsDecoderOwned::new(1024));
 
     if cli.ping {
-        let tc = create_stm32f3_tc(&embedded_models::stm32f3::Request::Ping);
+        let request = Request::Ping;
+        let tc = create_stm32f3_tc(&request);
         log::info!(
             "Sending ping request with TC ID: {:#010x}",
             tc.ccsds_packet_id_and_psc().raw()
@@ -38,7 +79,7 @@ fn main() {
     }
 
     if let Some(freq_ms) = cli.set_led_frequency {
-        let request = stm32f3::Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        let request = 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}",
@@ -59,7 +100,7 @@ fn main() {
     }
 }
 
-fn create_stm32f3_tc(request: &stm32f3::Request) -> CcsdsPacketCreatorOwned {
+fn create_stm32f3_tc(request: &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/models/Cargo.toml

@@ -1,11 +0,0 @@
-[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

@@ -1,84 +0,0 @@
-#![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.lock

@@ -592,17 +592,6 @@ dependencies = [
  "embedded-io",
 ]
 
-[[package]]
-name = "embedded-models"
-version = "0.1.0"
-dependencies = [
- "arbitrary-int 2.0.0",
- "defmt 1.0.1",
- "postcard",
- "serde",
- "spacepackets",
-]
-
 [[package]]
 name = "embedded-storage"
 version = "0.3.1"
@@ -953,7 +942,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
 dependencies = [
  "cobs 0.3.0",
- "defmt 1.0.1",
  "heapless 0.7.17",
  "serde",
 ]
@@ -1151,7 +1139,6 @@ dependencies = [
  "defmt-test",
  "embassy-stm32",
  "embedded-hal 1.0.0",
- "embedded-models",
  "enumset",
  "heapless 0.9.1",
  "panic-probe",
@@ -1258,8 +1245,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 [[package]]
 name = "spacepackets"
 version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94979a990b4333f43667cba9fe9e72b9c4e9ada82e09fbe8fb250844358590cc"
+source = "git+https://egit.irs.uni-stuttgart.de/rust/spacepackets.git#2bc61677105765e69cc96bb1ff9960557c00fa8e"
 dependencies = [
  "arbitrary-int 2.0.0",
  "bitbybit",

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

@@ -7,7 +7,6 @@ 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"

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

@@ -1,10 +1,13 @@
 #![no_main]
 #![no_std]
 
-use defmt_rtt 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);
 
@@ -37,6 +40,49 @@ 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,9 +1,9 @@
 #![no_std]
 #![no_main]
-use arbitrary_int::u14;
+use arbitrary_int::{u11, u14};
 use cortex_m_semihosting::debug::{self, EXIT_FAILURE, EXIT_SUCCESS};
-use embedded_models::{create_tm_packet, stm32f3, tm_size, TmHeader};
-use spacepackets::{CcsdsPacketCreationError, CcsdsPacketIdAndPsc, SpHeader};
+use satrs_stm32f3_disco_rtic::{create_tm_packet, tm_size, CcsdsPacketId, Request, Response};
+use spacepackets::{CcsdsPacketCreationError, SpHeader};
 
 use defmt_rtt as _; // global logger
 
@@ -23,6 +23,8 @@ 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);
@@ -45,8 +47,8 @@ pub enum TmSendError {
 
 #[derive(Debug, defmt::Format)]
 pub struct RequestWithTcId {
-    pub request: stm32f3::Request,
-    pub tc_id: CcsdsPacketIdAndPsc,
+    pub request: Request,
+    pub tc_id: CcsdsPacketId,
 }
 
 #[app(device = embassy_stm32)]
@@ -55,13 +57,12 @@ mod app {
 
     use super::*;
     use arbitrary_int::u14;
-    use embedded_models::stm32f3::{Request, Response};
     use rtic::Mutex;
     use rtic_sync::{
         channel::{Receiver, Sender},
         make_channel,
     };
-    use satrs_stm32f3_disco_rtic::LedPinSet;
+    use satrs_stm32f3_disco_rtic::{CcsdsPacketId, LedPinSet, Request, Response};
     use spacepackets::CcsdsPacketReader;
 
     systick_monotonic!(Mono, 1000);
@@ -199,7 +200,7 @@ mod app {
                                     Ok(packet) => {
                                         let packet_id = packet.packet_id();
                                         let psc = packet.psc();
-                                        let tc_packet_id = CcsdsPacketIdAndPsc { packet_id, psc };
+                                        let tc_packet_id = CcsdsPacketId { packet_id, psc };
                                         if let Ok(request) =
                                             postcard::from_bytes::<Request>(packet.packet_data())
                                         {
@@ -259,17 +260,17 @@ mod app {
 
     fn handle_ping_request(
         cx: &mut req_handler::Context,
-        tc_packet_id: CcsdsPacketIdAndPsc,
+        tc_packet_id: CcsdsPacketId,
     ) -> Result<(), TmSendError> {
         defmt::info!("Received PUS ping telecommand, sending ping reply");
-        send_tm(tc_packet_id, Response::Ok, *cx.local.seq_count)?;
+        send_tm(tc_packet_id, Response::CommandDone, *cx.local.seq_count)?;
         *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: CcsdsPacketIdAndPsc,
+        tc_packet_id: CcsdsPacketId,
         duration: Duration,
     ) -> Result<(), TmSendError> {
         defmt::info!(
@@ -279,21 +280,21 @@ mod app {
         cx.shared
             .blink_freq
             .lock(|blink_freq| *blink_freq = duration);
-        send_tm(tc_packet_id, Response::Ok, *cx.local.seq_count)?;
+        send_tm(tc_packet_id, Response::CommandDone, *cx.local.seq_count)?;
         *cx.local.seq_count = cx.local.seq_count.wrapping_add(u14::new(1));
         Ok(())
     }
 }
 
 fn send_tm(
-    tc_packet_id: CcsdsPacketIdAndPsc,
-    response: stm32f3::Response,
+    tc_packet_id: CcsdsPacketId,
+    response: Response,
     current_seq_count: u14,
 ) -> Result<(), TmSendError> {
-    let sp_header = SpHeader::new_for_unseg_tc(stm32f3::PUS_APID, current_seq_count, 0);
-    let tm_header = TmHeader {
+    let sp_header = SpHeader::new_for_unseg_tc(PUS_APID, current_seq_count, 0);
+    let tm_header = satrs_stm32f3_disco_rtic::TmHeader {
         tc_packet_id: Some(tc_packet_id),
-        uptime_millis: Mono::now().duration_since_epoch().to_millis() as u64,
+        uptime_millis: Mono::now().duration_since_epoch().to_millis(),
     };
     let mut tm_packet = TmPacket::new();
     let tm_size = tm_size(&tm_header, &response);

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

@@ -0,0 +1,29 @@
+[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,28 +14,37 @@ 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-rtt = "1"
+defmt-brtt = { version = "0.1", default-features = false, features = ["rtt"] }
 panic-probe = { version = "1", features = ["print-defmt"] }
-embedded-alloc = "0.7"
-static_cell = "2"
-rtic = { version = "2", features = ["thumbv7-backend"] }
-spacepackets = { version = "0.17", default-features = false, features = ["defmt"] }
-postcard = "1"
+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"] }
 
-embassy-stm32 =  { git = "https://github.com/embassy-rs/embassy.git", rev = "dd8e4c14e53f088bae27c5d841ab7a4fa338a52c", version = "0.6", features = ["stm32h743zi", "memory-x", "defmt", "time-driver-any"]}
+[dependencies.smoltcp]
+version = "0.12"
+default-features = false
+features = ["medium-ethernet", "proto-ipv4", "socket-raw", "socket-dhcpv4", "socket-udp", "defmt"]
 
-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" }
+[dependencies.rtic]
+version = "2"
+features = ["thumbv7-backend"]
+
+[dependencies.rtic-monotonics]
+version = "2"
+features = ["cortex-m-systick"]
+
+[dependencies.satrs]
+path = "../../satrs"
+default-features = false
+features = ["defmt", "heapless"]
 
 [dev-dependencies]
-defmt-test = "0.5"
+defmt-test = "0.4"
 
 # cargo build/run
 [profile.dev]

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

@@ -1,14 +0,0 @@
-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

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

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

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

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

@@ -0,0 +1,305 @@
+#!/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

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

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

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

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

@@ -5,53 +5,51 @@
 
 #![no_std]
 #![no_main]
-use rtic::app;
 use satrs_stm32h7_nucleo_rtic as _;
 
-#[app(device = embassy_stm32, peripherals = false, dispatchers = [SPI1])]
-mod app {
-    use embassy_stm32::gpio;
+use stm32h7xx_hal::{block, prelude::*, timer::Timer};
 
-    #[shared]
-    struct Shared {}
+use cortex_m_rt::entry;
 
-    #[local]
-    struct Local {}
+#[entry]
+fn main() -> ! {
+    defmt::println!("starting stm32h7 blinky example");
 
-    #[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);
+    // Get access to the device specific peripherals from the peripheral access crate
+    let dp = stm32h7xx_hal::stm32::Peripherals::take().unwrap();
 
-        // Schedule the blinking task
-        blink::spawn(ld1, ld2, ld3).ok();
+    // Take ownership over the RCC devices and convert them into the corresponding HAL structs
+    let rcc = dp.RCC.constrain();
 
-        (Shared {}, Local {})
-    }
+    let pwr = dp.PWR.constrain();
+    let pwrcfg = pwr.freeze();
 
-    #[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;
+    // 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);
 
-            defmt::info!("low");
-            ld1.set_low();
-            ld2.set_low();
-            ld3.set_low();
-            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();
     }
 }

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

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

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

@@ -1,8 +1,13 @@
 #![no_main]
 #![no_std]
 
-use defmt_rtt as _;
-use embassy_stm32 as _;
+use cortex_m_semihosting::debug;
+
+use defmt_brtt as _; // global logger
+
+// TODO(5) adjust HAL import
+use stm32h7xx_hal as _; // memory layout
+
 use panic_probe as _;
 
 // same panicking *behavior* as `panic-probe` but doesn't print a panic message
@@ -12,6 +17,14 @@ 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
@@ -19,7 +32,9 @@ fn panic() -> ! {
 /// loop.
 #[cortex_m_rt::exception]
 unsafe fn HardFault(_frame: &cortex_m_rt::ExceptionFrame) -> ! {
-    panic!("unexpected hard fault");
+    loop {
+        debug::exit(debug::EXIT_FAILURE);
+    }
 }
 
 // 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,215 +3,422 @@
 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];
 
-const TC_QUEUE_DEPTH: usize = 32;
-const TM_QUEUE_DEPTH: usize = 32;
+pub struct Net {
+    iface: Interface,
+    ethdev: ethernet::EthernetDMA<4, 4>,
+    dhcp_handle: SocketHandle,
+}
 
-#[app(device = embassy_stm32, peripherals = false)]
+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)]
 mod app {
+    use core::ptr::addr_of_mut;
 
     use super::*;
-    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>>,
-    >;
+    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;
 
     struct BlinkyLeds {
-        led1: gpio::Output<'static>,
-        led2: gpio::Output<'static>,
+        led1: Pin<'B', 7, Output>,
+        led2: Pin<'B', 14, Output>,
     }
 
     #[local]
     struct Local {
-        net_runner: embassy_net::Runner<'static, Device>,
-        net_stack: embassy_net::Stack<'static>,
         leds: BlinkyLeds,
-        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,
-        >,
+        link_led: Pin<'B', 0, Output>,
+        net: Net,
+        udp: UdpNet,
+        tc_source_rx: TcSourceRx,
+        phy: ethernet::phy::LAN8742A<EthernetMAC>,
     }
 
     #[shared]
     struct Shared {
-        sequence_count: u14,
-        blink_freq: embassy_time::Duration,
+        blink_freq: MillisDurationU32,
+        eth_link_up: bool,
+        sockets: SocketSet<'static>,
+        shared_pool: SharedPool,
     }
 
     #[init]
-    fn init(_cx: init::Context) -> (Shared, Local) {
+    fn init(mut cx: init::Context) -> (Shared, Local) {
         defmt::println!("Starting sat-rs demo application for the STM32H743ZIT");
 
-        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 pwr = cx.device.PWR.constrain();
+        let pwrcfg = pwr.freeze();
 
-        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);
+        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();
 
         // Criss-cross pattern looks cooler.
         led1.set_high();
         led2.set_low();
         let leds = BlinkyLeds { led1, led2 };
 
-        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
+        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"
         );
 
-        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);
+        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");
 
         // 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) }
 
-        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");
+        eth_link_check::spawn().expect("eth link check failed");
         blinky::spawn().expect("spawning blink task failed");
-        tc_handler::spawn().expect("spawning TC handler task failed");
+        udp_task::spawn().expect("spawning UDP task failed");
+        tc_source_task::spawn().expect("spawning TC source task failed");
 
         (
             Shared {
-                blink_freq: Duration::from_millis(DEFAULT_BLINK_FREQ_MS as u64),
-                sequence_count: u14::new(0),
+                blink_freq: MillisDurationU32::from_ticks(DEFAULT_BLINK_FREQ_MS),
+                eth_link_up: false,
+                sockets,
+                shared_pool,
             },
             Local {
                 link_led,
                 leds,
-                net_runner: runner,
-                net_stack: stack,
-                tc_tx: tc_sender,
-                tc_rx: tc_receiver,
-                tm_tx: tm_sender,
-                tm_rx: tm_receiver,
+                net,
+                udp,
+                tc_source_rx,
+                phy: lan8742a,
             },
         )
     }
@@ -223,159 +430,94 @@ mod app {
             leds.led1.toggle();
             leds.led2.toggle();
             let current_blink_freq = cx.shared.blink_freq.lock(|current| *current);
-            Timer::after_millis(current_blink_freq.as_millis()).await;
+            Mono::delay(current_blink_freq).await;
         }
     }
 
-    #[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];
-
+    /// 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;
         loop {
-            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;
-                }
-                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) => (),
-                }
-                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),
-                        }
-                    }
+            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");
                 }
+            } 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(local = [tc_rx, tm_tx], shared=[sequence_count, blink_freq])]
-    async fn tc_handler(mut cx: tc_handler::Context) {
+    #[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 {
-            let tc = cx.local.tc_rx.receive().await;
-
-            match CcsdsPacketReader::new_with_checksum(&tc) {
-                Ok(packet) => {
-                    let packet_id = packet.packet_id();
-                    let psc = packet.psc();
-                    let tc_packet_id = CcsdsPacketIdAndPsc { packet_id, psc };
-                    if let Ok(request) =
-                        postcard::from_bytes::<stm32h7::Request>(packet.packet_data())
-                    {
-                        let response = match request {
-                            stm32h7::Request::Ping => {
-                                stm32h7::Response::Ok
-                            }
-                            stm32h7::Request::ChangeBlinkFrequency(duration) => {
-                                cx.shared.blink_freq.lock(|current| {
-                                    *current = Duration::from_millis(duration.as_millis() as u64)
-                                });
-                                stm32h7::Response::Ok
-                            }
-                        };
-                        let sequence_count = cx.shared.sequence_count.lock(|v| {
-                            let current = *v;
-                            *v = v.wrapping_add(u14::new(1));
-                            current
-                        });
-
-                        // Send Pong/OK response immediately.
-                        if let Err(e) =
-                            send_tm(tc_packet_id, response, sequence_count, cx.local.tm_tx).await
-                        {
-                            defmt::warn!("Failed to send TM response: {}", e);
-                        }
-                    }
-                }
-                Err(e) => defmt::warn!("Failed to parse received TC packet: {}", e,),
-            }
-            defmt::info!("Received from UDP client: {}", tc.as_slice());
+            cx.shared.sockets.lock(|sockets| {
+                cx.shared.shared_pool.lock(|pool| {
+                    cx.local.udp.poll(sockets, pool);
+                })
+            });
+            Mono::delay(40.millis()).await;
         }
     }
 
-    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(())
+    /// 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);
+                            }
+                        }
+                    });
+                }
+                Err(e) => {
+                    defmt::warn!("TC source reception error: {}", e);
+                }
+            };
+        }
     }
 }

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

@@ -1,7 +1,7 @@
 #![no_std]
 #![no_main]
 
-use satrs_stm32h7_nucleo_rtic as _; // memory layout + panic handler
+use stm32h7_testapp 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

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

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

@@ -0,0 +1,12 @@
+{
+	// 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

@@ -0,0 +1,22 @@
+{
+  "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

@@ -0,0 +1,20 @@
+{
+    // 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,17 +11,9 @@ test:
   cargo nextest run --all-features
   cargo test --doc --all-features
 
-embedded: embedded-stm32h7 embedded-stm32f3
+embedded:
   cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
 
-[working-directory:"embedded-examples/stm32h7-nucleo-rtic"]
-embedded-stm32h7:
-  cargo build --target=thumbv7em-none-eabihf --release
-
-[working-directory:"embedded-examples/stm32f3-disco-rtic"]
-embedded-stm32f3:
-  cargo build --target=thumbv7em-none-eabihf --release
-
 check-fmt:
   cargo fmt --all -- --check
 

satrs-example/client/src/main.rs

@@ -1,7 +1,7 @@
 use anyhow::bail;
 use arbitrary_int::u11;
 use clap::Parser as _;
-use models::{Apid, MessageType, TcHeader, mgm::request::HkRequest};
+use models::{Apid, MessageType, TcHeader, acs::mgm::request::HkRequest};
 use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
 use spacepackets::{CcsdsPacketIdAndPsc, SpacePacketHeader};
 use std::{
@@ -136,7 +136,7 @@ fn main() -> anyhow::Result<()> {
                     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,
+                        models::acs::mgm::request::Request::Ping,
                     );
                     let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
                     log::info!(
@@ -151,8 +151,8 @@ fn main() -> anyhow::Result<()> {
                     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,
+                        models::acs::mgm::request::Request::Hk(HkRequest {
+                            id: models::acs::mgm::request::HkId::Sensor,
                             req_type: models::HkRequestType::OneShot,
                         }),
                     );
@@ -174,8 +174,8 @@ fn main() -> anyhow::Result<()> {
                     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),
+                        models::acs::mgm::request::Request::Mode(
+                            models::acs::mgm::request::ModeRequest::SetMode(dev_mode),
                         ),
                     );
                     let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
@@ -193,7 +193,7 @@ fn main() -> anyhow::Result<()> {
                     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,
+                        models::acs::mgm::request::Request::Ping,
                     );
                     let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
                     log::info!(
@@ -207,21 +207,23 @@ fn main() -> anyhow::Result<()> {
                 if let Some(mode) = mgm_assembly_args.mode {
                     let assembly_mode = match mode {
                         AssemblyModeSelect::NoModeKeeping => {
-                            models::mgm_assembly::AssemblyMode::NoModeKeeping
+                            models::acs::mgm_assembly::Mode::NoModeKeeping
                         }
                         AssemblyModeSelect::Off => {
-                            models::mgm_assembly::AssemblyMode::Device(models::DeviceMode::Off)
+                            models::acs::mgm_assembly::Mode::Device(models::DeviceMode::Off)
                         }
                         AssemblyModeSelect::Normal => {
-                            models::mgm_assembly::AssemblyMode::Device(models::DeviceMode::Normal)
+                            models::acs::mgm_assembly::Mode::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),
+                        models::acs::mgm_assembly::request::Request::Mode(
+                            models::acs::mgm_assembly::request::ModeRequest::SetMode(assembly_mode),
                         ),
                     );
                     let sent_tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&request.sp_header);
@@ -304,8 +306,9 @@ fn handle_raw_tm_packet(data: &[u8]) -> anyhow::Result<()> {
                 }
                 models::ComponentId::AcsSubsystem => todo!(),
                 models::ComponentId::AcsMgmAssembly => {
-                    let response =
-                        postcard::from_bytes::<models::mgm_assembly::response::Response>(remainder);
+                    let response = postcard::from_bytes::<
+                        models::acs::mgm_assembly::response::Response,
+                    >(remainder);
                     log::info!(
                         "Received response from MGM Assembly: {:?}",
                         response.unwrap()
@@ -313,12 +316,12 @@ fn handle_raw_tm_packet(data: &[u8]) -> anyhow::Result<()> {
                 }
                 models::ComponentId::AcsMgm0 => {
                     let response =
-                        postcard::from_bytes::<models::mgm::response::Response>(remainder);
+                        postcard::from_bytes::<models::acs::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);
+                        postcard::from_bytes::<models::acs::mgm::response::Response>(remainder);
                     log::info!("Received response from MGM1: {:?}", response.unwrap());
                 }
                 models::ComponentId::EpsSubsystem => todo!(),

satrs-example/models/src/acs/ctrl.rs

@@ -0,0 +1,28 @@
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Mode {
+    Passive,
+    Safe,
+    Idle,
+}
+
+pub mod request {
+    use super::Mode;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeRequest {
+        SetMode(Mode),
+        ReadMode,
+    }
+}
+
+pub mod response {
+    use super::Mode;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeReport {
+        /// Mode of the assembly.
+        Mode(super::Mode),
+        /// Children are in wrong mode after commanding.
+        WrongMode([Option<Mode>; 2]),
+    }
+}

satrs-example/models/src/acs/mgm.rs

@@ -42,7 +42,7 @@ pub mod request {
 }
 
 #[derive(Default, Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
-pub struct MgmData {
+pub struct SensorData {
     pub valid: bool,
     pub x: f32,
     pub y: f32,
@@ -50,11 +50,11 @@ pub struct MgmData {
 }
 
 pub mod response {
-    use crate::{DeviceMode, Message, mgm::MgmData};
+    use crate::{DeviceMode, Message, acs::mgm::SensorData};
 
     #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
     pub enum HkResponse {
-        MgmData(MgmData),
+        MgmData(SensorData),
     }
 
     #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy)]

satrs-example/models/src/acs/mgm_assembly.rs

@@ -3,7 +3,7 @@ use core::str::FromStr;
 use crate::DeviceMode;
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AssemblyMode {
+pub enum Mode {
     /// 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),
@@ -11,22 +11,22 @@ pub enum AssemblyMode {
     NoModeKeeping,
 }
 
-impl FromStr for AssemblyMode {
+impl FromStr for Mode {
     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),
+            "off" => Ok(Mode::Device(DeviceMode::Off)),
+            "on" => Ok(Mode::Device(DeviceMode::On)),
+            "normal" => Ok(Mode::Device(DeviceMode::Normal)),
+            "no_mode_keeping" => Ok(Mode::NoModeKeeping),
             _ => Err(()),
         }
     }
 }
 
 pub mod request {
-    use crate::{HkRequestType, Message, mgm_assembly::AssemblyMode};
+    use crate::{HkRequestType, Message, acs::mgm_assembly::Mode};
 
     #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
     pub enum HkId {
@@ -35,7 +35,7 @@ pub mod request {
 
     #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
     pub enum ModeRequest {
-        SetMode(AssemblyMode),
+        SetMode(Mode),
         ReadMode,
     }
 
@@ -77,7 +77,7 @@ pub mod response {
     #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
     pub enum ModeReport {
         /// Mode of the assembly.
-        Mode(super::AssemblyMode),
+        Mode(super::Mode),
         /// Timeout failure setting the children modes.
         SetModeTimeout([Option<DeviceMode>; 2]),
         /// Children are in wrong mode after commanding.

satrs-example/models/src/acs/mgt.rs

@@ -0,0 +1,27 @@
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Mode {
+    Off,
+    Normal,
+}
+
+pub mod request {
+    use super::*;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeRequest {
+        SetMode(Mode),
+        ReadMode,
+    }
+}
+
+pub mod response {
+    use super::*;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeReport {
+        /// Mode of the assembly.
+        Mode(super::Mode),
+        /// Children are in wrong mode after commanding.
+        WrongMode([Option<Mode>; 2]),
+    }
+}

satrs-example/models/src/acs/mod.rs

@@ -0,0 +1,5 @@
+pub mod ctrl;
+pub mod mgm;
+pub mod mgm_assembly;
+pub mod mgt;
+pub mod subsystem;

satrs-example/models/src/acs/subsystem.rs

@@ -0,0 +1,15 @@
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Mode {
+    Off,
+    Safe,
+}
+
+impl Mode {
+    /// Each subsystem mode has a fallback mode to allow clean transitions.
+    pub const fn fallback_mode(&self) -> Self {
+        match self {
+            Mode::Off => Mode::Safe,
+            Mode::Safe => Mode::Safe,
+        }
+    }
+}

satrs-example/models/src/lib.rs

@@ -6,10 +6,9 @@ use spacepackets::{
     time::cds::{CdsTime, MIN_CDS_FIELD_LEN},
 };
 
+pub mod acs;
 pub mod ccsds;
 pub mod control;
-pub mod mgm;
-pub mod mgm_assembly;
 pub mod pcdu;
 
 #[derive(

satrs-example/src/acs/mgm.rs

@@ -1,8 +1,8 @@
-use models::mgm::MgmData;
-use models::mgm::request::ModeRequest;
-use models::mgm::response::ModeResponse;
+use models::acs::mgm::SensorData;
+use models::acs::mgm::request::ModeRequest;
+use models::acs::mgm::response::ModeResponse;
 use models::pcdu::SwitchId;
-use models::{ComponentId, DeviceMode, HkRequestType, mgm};
+use models::{ComponentId, DeviceMode, HkRequestType, acs::mgm};
 use satrs::spacepackets::CcsdsPacketIdAndPsc;
 use satrs_example::{HkHelperSingleSet, ModeHelper, TimestampHelper, TmtcQueues};
 use satrs_minisim::acs::MgmRequestLis3Mdl;
@@ -153,7 +153,7 @@ pub struct MgmHandlerLis3Mdl {
     switch_helper: PowerSwitchHelper,
     tmtc_queues: TmtcQueues,
     pub spi_com: SpiCommunication,
-    shared_mgm_set: Arc<Mutex<MgmData>>,
+    shared_mgm_set: Arc<Mutex<SensorData>>,
     buffers: BufWrapper,
     stamp_helper: TimestampHelper,
     hk_helper: HkHelperSingleSet,
@@ -167,7 +167,7 @@ impl MgmHandlerLis3Mdl {
         tmtc_queues: TmtcQueues,
         switch_helper: PowerSwitchHelper,
         spi_com: SpiCommunication,
-        shared_mgm_set: Arc<Mutex<MgmData>>,
+        shared_mgm_set: Arc<Mutex<SensorData>>,
         mode_leaf_helper: ModeLeafHelper,
         mode_timeout: Duration,
     ) -> Self {
@@ -308,7 +308,7 @@ impl MgmHandlerLis3Mdl {
     pub fn handle_hk_request(
         &mut self,
         tc_id: Option<CcsdsPacketIdAndPsc>,
-        hk_request: &models::mgm::request::HkRequest,
+        hk_request: &models::acs::mgm::request::HkRequest,
     ) {
         match hk_request.req_type {
             HkRequestType::OneShot => {
@@ -462,8 +462,8 @@ mod tests {
     use arbitrary_int::u11;
     use models::{
         Apid, ComponentId, TcHeader,
+        acs::mgm::request::HkRequest,
         ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned},
-        mgm::request::HkRequest,
         pcdu::{SwitchRequest, SwitchState, SwitchStateBinary},
     };
     use satrs::{request::GenericMessage, spacepackets::SpacePacketHeader};
@@ -490,7 +490,7 @@ mod tests {
 
     pub fn create_request_tc(
         select: MgmSelect,
-        request: models::mgm::request::Request,
+        request: models::acs::mgm::request::Request,
     ) -> models::ccsds::CcsdsTcPacketOwned {
         models::ccsds::CcsdsTcPacketOwned::new_with_request(
             SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
@@ -533,7 +533,7 @@ mod tests {
                 SpiCommunication::Test(TestSpiInterface::default()),
                 shared_mgm_set,
                 mode_leaf_helper,
-                Duration::from_millis(200),
+                Duration::from_millis(100),
             );
             Self {
                 assembly_mode_request_tx,
@@ -601,9 +601,10 @@ mod tests {
 
         assert_eq!(tm_packet.tm_header.sender_id, ComponentId::AcsMgm0);
 
-        let response = postcard::from_bytes::<models::mgm::response::Response>(&tm_packet.payload)
-            .expect("failed to deserialize mode reply");
-        matches!(response, models::mgm::response::Response::Ok);
+        let response =
+            postcard::from_bytes::<models::acs::mgm::response::Response>(&tm_packet.payload)
+                .expect("failed to deserialize mode reply");
+        matches!(response, models::acs::mgm::response::Response::Ok);
         // The device should have been polled once.
         assert_eq!(testbench.test_spi_interface().call_count, 1);
         let mgm_set = *testbench.handler.shared_mgm_set.lock().unwrap();
@@ -689,9 +690,10 @@ mod tests {
 
         assert_eq!(tm_packet.tm_header.sender_id, ComponentId::AcsMgm0);
 
-        let response = postcard::from_bytes::<models::mgm::response::Response>(&tm_packet.payload)
-            .expect("failed to deserialize mode reply");
-        if let models::mgm::response::Response::Hk(mgm::response::HkResponse::MgmData(data)) =
+        let response =
+            postcard::from_bytes::<models::acs::mgm::response::Response>(&tm_packet.payload)
+                .expect("failed to deserialize mode reply");
+        if let models::acs::mgm::response::Response::Hk(mgm::response::HkResponse::MgmData(data)) =
             response
         {
             assert_eq!(data.valid, false);
@@ -740,17 +742,18 @@ mod tests {
 
         assert_eq!(mode_tm.tm_header.sender_id, ComponentId::AcsMgm0);
 
-        let response = postcard::from_bytes::<models::mgm::response::Response>(&mode_tm.payload)
-            .expect("failed to deserialize mode reply");
-        matches!(response, models::mgm::response::Response::Ok);
+        let response =
+            postcard::from_bytes::<models::acs::mgm::response::Response>(&mode_tm.payload)
+                .expect("failed to deserialize mode reply");
+        matches!(response, models::acs::mgm::response::Response::Ok);
 
         let hk_tm = testbench.tm_rx.try_recv().expect("no hk reply generated");
 
         assert_eq!(hk_tm.tm_header.sender_id, ComponentId::AcsMgm0);
 
-        let response = postcard::from_bytes::<models::mgm::response::Response>(&hk_tm.payload)
+        let response = postcard::from_bytes::<models::acs::mgm::response::Response>(&hk_tm.payload)
             .expect("failed to deserialize mode reply");
-        if let models::mgm::response::Response::Hk(mgm::response::HkResponse::MgmData(data)) =
+        if let models::acs::mgm::response::Response::Hk(mgm::response::HkResponse::MgmData(data)) =
             response
         {
             // Set is now valid.

satrs-example/src/acs/mgm_assembly.rs

@@ -2,7 +2,7 @@ use std::{sync::mpsc, time::Duration};
 
 use models::{
     ComponentId, DeviceMode,
-    mgm_assembly::{AssemblyMode, request, response},
+    acs::mgm_assembly::{Mode, request, response},
 };
 use satrs::spacepackets::CcsdsPacketIdAndPsc;
 use satrs_example::{ModeHelper, TmtcQueues};
@@ -16,8 +16,8 @@ pub struct ParentQueueHelper {
 
 /// 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],
+    pub request_tx_queues: [mpsc::SyncSender<models::acs::mgm::request::ModeRequest>; 2],
+    pub report_rx_queues: [mpsc::Receiver<models::acs::mgm::response::ModeResponse>; 2],
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
@@ -35,7 +35,7 @@ pub struct MgmInfo {
 
 /// MGM assembly component.
 pub struct Assembly {
-    mode_helper: ModeHelper<AssemblyMode, TransitionState>,
+    mode_helper: ModeHelper<Mode, 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.
@@ -56,7 +56,7 @@ impl Assembly {
         mode_timeout: Duration,
     ) -> Self {
         Self {
-            mode_helper: ModeHelper::new(AssemblyMode::NoModeKeeping, mode_timeout),
+            mode_helper: ModeHelper::new(Mode::NoModeKeeping, mode_timeout),
             mode_keeping_transition: false,
             tmtc_queues,
             mgm_modes: [MgmInfo::default(); 2],
@@ -80,14 +80,14 @@ impl Assembly {
             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>(
+                    match postcard::from_bytes::<models::acs::mgm_assembly::request::Request>(
                         &packet.payload,
                     ) {
                         Ok(request) => match request {
-                            models::mgm_assembly::request::Request::Ping => {
+                            models::acs::mgm_assembly::request::Request::Ping => {
                                 self.send_telemetry(Some(tc_id), response::Response::Ok)
                             }
-                            models::mgm_assembly::request::Request::Mode(request) => {
+                            models::acs::mgm_assembly::request::Request::Mode(request) => {
                                 match request {
                                     request::ModeRequest::SetMode(assembly_mode) => {
                                         self.start_transition(false, assembly_mode, Some(tc_id))
@@ -117,7 +117,7 @@ impl Assembly {
     pub fn send_telemetry(
         &self,
         tc_id: Option<CcsdsPacketIdAndPsc>,
-        response: models::mgm_assembly::response::Response,
+        response: models::acs::mgm_assembly::response::Response,
     ) {
         match pack_ccsds_tm_packet_for_now(Self::ID, tc_id, &response) {
             Ok(packet) => {
@@ -136,11 +136,11 @@ impl Assembly {
             match self.parent_queues.request_rx.try_recv() {
                 Ok(request) => match request {
                     request::ModeRequest::SetMode(assembly_mode) => match assembly_mode {
-                        AssemblyMode::Device(_device_mode) => {
+                        Mode::Device(_device_mode) => {
                             self.start_transition(false, assembly_mode, None);
                         }
-                        AssemblyMode::NoModeKeeping => {
-                            self.mode_helper.current = AssemblyMode::NoModeKeeping;
+                        Mode::NoModeKeeping => {
+                            self.mode_helper.current = Mode::NoModeKeeping;
                         }
                     },
                     request::ModeRequest::ReadMode => self
@@ -165,12 +165,12 @@ impl Assembly {
             loop {
                 match rx.try_recv() {
                     Ok(report) => match report {
-                        models::mgm::response::ModeResponse::Mode(device_mode) => {
+                        models::acs::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 => {
+                        models::acs::mgm::response::ModeResponse::SetModeTimeout => {
                             // Ignore, handle this with our own timeout.
                             log::warn!("MGM {} mode timeout", idx);
                         }
@@ -191,7 +191,7 @@ impl Assembly {
         // 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()
+            && let Mode::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)) {
@@ -207,7 +207,7 @@ impl Assembly {
         }
 
         // Mode keeping active: Check children modes.
-        if let AssemblyMode::Device(device_mode) = self.mode_helper.current
+        if let Mode::Device(device_mode) = self.mode_helper.current
             && self
                 .mgm_modes
                 .iter()
@@ -226,8 +226,8 @@ impl Assembly {
         }
         let target = self.mode_helper.target.unwrap();
         let device_mode = match target {
-            AssemblyMode::Device(device_mode) => device_mode,
-            AssemblyMode::NoModeKeeping => {
+            Mode::Device(device_mode) => device_mode,
+            Mode::NoModeKeeping => {
                 self.handle_mode_reached(true);
                 return;
             }
@@ -275,7 +275,7 @@ impl Assembly {
 
     pub fn command_children(&self, mode: DeviceMode) {
         for tx in &self.children_queues.request_tx_queues {
-            tx.send(models::mgm::request::ModeRequest::SetMode(mode))
+            tx.send(models::acs::mgm::request::ModeRequest::SetMode(mode))
                 .unwrap();
         }
     }
@@ -283,7 +283,7 @@ impl Assembly {
     pub fn start_transition(
         &mut self,
         mode_keeping: bool,
-        target: AssemblyMode,
+        target: Mode,
         tc_id: Option<CcsdsPacketIdAndPsc>,
     ) {
         self.mode_keeping_transition = mode_keeping;
@@ -304,7 +304,7 @@ impl Assembly {
     }
 
     #[inline]
-    pub fn mode(&self) -> AssemblyMode {
+    pub fn mode(&self) -> Mode {
         self.mode_helper.current
     }
 
@@ -322,8 +322,8 @@ mod tests {
     use arbitrary_int::u11;
     use models::{
         Apid, Message, MessageType, TcHeader,
+        acs::mgm_assembly,
         ccsds::{CcsdsTcPacketOwned, CcsdsTmPacketOwned},
-        mgm_assembly,
     };
     use satrs::spacepackets::SpacePacketHeader;
 
@@ -332,8 +332,8 @@ mod tests {
     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],
+        mgm_request_rx: [mpsc::Receiver<models::acs::mgm::request::ModeRequest>; 2],
+        mgm_report_tx: [mpsc::SyncSender<models::acs::mgm::response::ModeResponse>; 2],
         tc_tx: mpsc::SyncSender<CcsdsTcPacketOwned>,
         tm_rx: mpsc::Receiver<CcsdsTmPacketOwned>,
         assembly: Assembly,
@@ -396,7 +396,7 @@ mod tests {
     }
 
     pub fn create_request_tc(
-        request: models::mgm_assembly::request::Request,
+        request: models::acs::mgm_assembly::request::Request,
     ) -> models::ccsds::CcsdsTcPacketOwned {
         models::ccsds::CcsdsTcPacketOwned::new_with_request(
             SpacePacketHeader::new_from_apid(u11::new(Apid::Acs as u16)),
@@ -411,7 +411,7 @@ mod tests {
         tb.assert_all_queues_empty();
         tb.assembly.periodic_operation();
         tb.assert_all_queues_empty();
-        assert_eq!(tb.assembly.mode(), AssemblyMode::NoModeKeeping);
+        assert_eq!(tb.assembly.mode(), Mode::NoModeKeeping);
     }
 
     #[test]
@@ -419,7 +419,7 @@ mod tests {
         let mut tb = Testbench::new();
         tb.tc_tx
             .send(create_request_tc(mgm_assembly::request::Request::Mode(
-                request::ModeRequest::SetMode(AssemblyMode::Device(DeviceMode::Normal)),
+                request::ModeRequest::SetMode(Mode::Device(DeviceMode::Normal)),
             )))
             .unwrap();
         tb.assembly.periodic_operation();
@@ -429,13 +429,13 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::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(
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
                 DeviceMode::Normal,
             ))
             .unwrap();
@@ -443,7 +443,7 @@ mod tests {
 
         tb.assembly.periodic_operation();
         assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
+        assert_eq!(tb.assembly.mode(), Mode::Device(DeviceMode::Normal));
 
         let response = tb.tm_rx.try_recv().unwrap();
         assert_eq!(response.tm_header.sender_id, Assembly::ID);
@@ -456,7 +456,7 @@ mod tests {
     fn test_parent_commanded_transition() {
         let mut tb = Testbench::new();
         tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
+            .send(request::ModeRequest::SetMode(Mode::Device(
                 DeviceMode::Normal,
             )))
             .unwrap();
@@ -467,13 +467,13 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::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(
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
                 DeviceMode::Normal,
             ))
             .unwrap();
@@ -481,12 +481,12 @@ mod tests {
 
         tb.assembly.periodic_operation();
         assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
+        assert_eq!(tb.assembly.mode(), Mode::Device(DeviceMode::Normal));
 
         let report = tb.subsystem_report_rx.try_recv().unwrap();
         assert_eq!(
             report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
+            response::ModeReport::Mode(Mode::Device(DeviceMode::Normal))
         );
     }
 
@@ -494,7 +494,7 @@ mod tests {
     fn test_one_mgm_is_sufficient() {
         let mut tb = Testbench::new();
         tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
+            .send(request::ModeRequest::SetMode(Mode::Device(
                 DeviceMode::Normal,
             )))
             .unwrap();
@@ -505,28 +505,30 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
             );
         }
 
         // One device is sufficient.
         tb.mgm_report_tx[0]
-            .send(models::mgm::response::ModeResponse::Mode(
+            .send(models::acs::mgm::response::ModeResponse::Mode(
                 DeviceMode::Normal,
             ))
             .unwrap();
         tb.mgm_report_tx[1]
-            .send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
+            .send(models::acs::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));
+        assert_eq!(tb.assembly.mode(), Mode::Device(DeviceMode::Normal));
 
         let report = tb.subsystem_report_rx.try_recv().unwrap();
         assert_eq!(
             report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
+            response::ModeReport::Mode(Mode::Device(DeviceMode::Normal))
         );
     }
 
@@ -534,7 +536,7 @@ mod tests {
     fn test_mode_commanding_fails() {
         let mut tb = Testbench::new();
         tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
+            .send(request::ModeRequest::SetMode(Mode::Device(
                 DeviceMode::Normal,
             )))
             .unwrap();
@@ -545,19 +547,21 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::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();
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
+                DeviceMode::Off,
+            ))
+            .unwrap();
         }
 
         tb.assembly.periodic_operation();
         assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::NoModeKeeping);
+        assert_eq!(tb.assembly.mode(), Mode::NoModeKeeping);
 
         let report = tb.subsystem_report_rx.try_recv().unwrap();
         assert_eq!(
@@ -570,7 +574,7 @@ mod tests {
     fn test_mode_keeping_fails() {
         let mut tb = Testbench::new();
         tb.subsystem_req_tx
-            .send(request::ModeRequest::SetMode(AssemblyMode::Device(
+            .send(request::ModeRequest::SetMode(Mode::Device(
                 DeviceMode::Normal,
             )))
             .unwrap();
@@ -581,13 +585,13 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::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(
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
                 DeviceMode::Normal,
             ))
             .unwrap();
@@ -595,17 +599,19 @@ mod tests {
 
         tb.assembly.periodic_operation();
         assert!(!tb.assembly.mode_transition_active());
-        assert_eq!(tb.assembly.mode(), AssemblyMode::Device(DeviceMode::Normal));
+        assert_eq!(tb.assembly.mode(), Mode::Device(DeviceMode::Normal));
 
         let report = tb.subsystem_report_rx.try_recv().unwrap();
         assert_eq!(
             report,
-            response::ModeReport::Mode(AssemblyMode::Device(DeviceMode::Normal))
+            response::ModeReport::Mode(Mode::Device(DeviceMode::Normal))
         );
 
         for tx in tb.mgm_report_tx.iter() {
-            tx.send(models::mgm::response::ModeResponse::Mode(DeviceMode::Off))
-                .unwrap();
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
+                DeviceMode::Off,
+            ))
+            .unwrap();
         }
         // This should start mode keeping.
         tb.assembly.periodic_operation();
@@ -615,14 +621,16 @@ mod tests {
             let request = rx.try_recv().unwrap();
             assert_eq!(
                 request,
-                models::mgm::request::ModeRequest::SetMode(DeviceMode::Normal)
+                models::acs::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();
+            tx.send(models::acs::mgm::response::ModeResponse::Mode(
+                DeviceMode::Off,
+            ))
+            .unwrap();
         }
         tb.assembly.periodic_operation();
         let report = tb.subsystem_report_rx.try_recv().unwrap();

satrs-example/src/acs/mgt.rs

@@ -0,0 +1 @@
+

satrs-example/src/acs/mod.rs

@@ -1,6 +1,5 @@
 pub mod ctrl;
-
 pub mod mgm;
 pub mod mgm_assembly;
-
+pub mod mgt;
 pub mod subsystem;

satrs-example/src/acs/subsystem.rs

@@ -1 +1,116 @@
-// TODO: Write subsystem
+use std::sync::mpsc::SyncSender;
+
+use models::ComponentId;
+
+#[derive(Debug)]
+pub struct TransitionInfo {
+    check_mode_reached: bool,
+}
+
+#[derive(Debug)]
+pub struct ChildModes {
+    mgm_assembly_mode: models::acs::mgm_assembly::Mode,
+    mgt_mode: models::acs::mgt::Mode,
+    controller_mode: models::acs::ctrl::Mode,
+}
+
+#[derive(Debug)]
+pub struct TransitionCommands {
+    mgm_assembly_mode: Option<(models::acs::mgm_assembly::Mode, TransitionInfo)>,
+    mgt_mode: Option<(models::acs::mgt::Mode, TransitionInfo)>,
+    controller_mode: Option<(models::acs::ctrl::Mode, TransitionInfo)>,
+}
+
+const OFF_SEQUENCE: [TransitionCommands; 2] = [
+    TransitionCommands {
+        mgm_assembly_mode: None,
+        mgt_mode: None,
+        controller_mode: Some((
+            models::acs::ctrl::Mode::Passive,
+            TransitionInfo {
+                check_mode_reached: true,
+            },
+        )),
+    },
+    TransitionCommands {
+        mgm_assembly_mode: Some((
+            models::acs::mgm_assembly::Mode::Device(models::DeviceMode::Off),
+            TransitionInfo {
+                check_mode_reached: false,
+            },
+        )),
+        mgt_mode: Some((
+            models::acs::mgt::Mode::Off,
+            TransitionInfo {
+                check_mode_reached: false,
+            },
+        )),
+        controller_mode: None,
+    },
+];
+
+const SAFE_SEQUENCE: [TransitionCommands; 2] = [
+    TransitionCommands {
+        mgm_assembly_mode: Some((
+            models::acs::mgm_assembly::Mode::Device(models::DeviceMode::Normal),
+            TransitionInfo {
+                check_mode_reached: false,
+            },
+        )),
+        mgt_mode: Some((
+            models::acs::mgt::Mode::Normal,
+            TransitionInfo {
+                check_mode_reached: false,
+            },
+        )),
+        controller_mode: None,
+    },
+    TransitionCommands {
+        mgm_assembly_mode: None,
+        mgt_mode: None,
+        controller_mode: Some((
+            models::acs::ctrl::Mode::Safe,
+            TransitionInfo {
+                check_mode_reached: false,
+            },
+        )),
+    },
+];
+
+#[derive(Debug)]
+pub struct ModeRequestSenders {
+    mode_request_ctrl: SyncSender<models::acs::ctrl::request::ModeRequest>,
+    mode_request_assy: SyncSender<models::acs::mgm_assembly::request::ModeRequest>,
+    mode_request_mgt: SyncSender<models::acs::mgt::request::ModeRequest>,
+}
+
+#[derive(Debug)]
+pub struct ModeReportReceivers {
+    mode_response_ctrl: SyncSender<models::acs::ctrl::response::ModeReport>,
+    mode_response_assy: SyncSender<models::acs::mgm_assembly::response::ModeReport>,
+    mode_response_mgt: SyncSender<models::acs::mgt::response::ModeReport>,
+}
+
+#[derive(Debug)]
+pub struct Subsystem {
+    current_mode: models::acs::subsystem::Mode,
+    current_child_modes: Option<ChildModes>,
+    mode_request_senders: ModeRequestSenders,
+    mode_report_receivers: ModeReportReceivers,
+}
+
+impl Subsystem {
+    pub const ID: ComponentId = ComponentId::AcsSubsystem;
+
+    pub fn new(
+        mode_request_senders: ModeRequestSenders,
+        mode_report_receivers: ModeReportReceivers,
+    ) -> Self {
+        Self {
+            current_mode: models::acs::subsystem::Mode::Off,
+            current_child_modes: None,
+            mode_request_senders,
+            mode_report_receivers,
+        }
+    }
+}