works now

embedded-examples/embedded-client/Cargo.toml

@@ -13,6 +13,7 @@ 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"] }
+anyhow = "1"
 cobs = "0.5"
 fern = "0.7"
 humantime = "2"

embedded-examples/embedded-client/config.toml

@@ -1,2 +1,3 @@
 [interface]
 serial_port = "/dev/ttyUSB0"
+udp_addr = "192.168.178.73:7301"

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

@@ -1,11 +1,11 @@
-use std::{fs::File, io::Read, path::Path, time::Duration};
+use std::{net::UdpSocket, time::Duration};
 
+use anyhow::{Context as _, bail};
 use clap::Parser;
-use cobs::CobsDecoderOwned;
 use embedded_client::setup_logger;
-use embedded_models::{stm32f3, stm32h7};
+use embedded_models::{TmHeader, stm32h7};
 use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
-use tmtc_utils::transport::serial::PacketTransportSerialCobs;
+use tmtc_utils::transport::udp::PacketTransportUdp;
 
 #[derive(Parser, Debug)]
 struct Cli {
@@ -15,18 +15,32 @@ struct Cli {
     /// Set frequency in milliseconds.
     #[arg(short, long)]
     set_led_frequency: Option<u32>,
+
+    /// UDP address to bind to.
+    #[arg(short, long)]
+    udp_addr: Option<std::net::SocketAddr>,
 }
 
-fn main() {
+fn main() -> anyhow::Result<()> {
     setup_logger().expect("failed to initialize logger");
     println!("-- STM32H7 TMTC client --");
     let cli = Cli::parse();
     let config = embedded_client::Config::new_from_file();
+    let mut udp_addr = cli.udp_addr;
+    if udp_addr.is_none() {
+        udp_addr = config.interface.udp_addr;
+    }
+    if udp_addr.is_none() {
+        bail!("UDP address not specified in config.toml or via command line");
+    }
+    let udp_addr = udp_addr.unwrap();
+    log::info!("binding to UDP address: {}", udp_addr);
+    let local_socket = UdpSocket::bind("0.0.0.0:0").expect("failed to bind UDP socket");
+    let mut transport = PacketTransportUdp::new(local_socket, udp_addr)
+        .with_context(|| "crateing UDP transport failed")?;
 
-
-    /*
     if cli.ping {
-        let tc = create_stm32f3_tc(&embedded_models::stm32f3::Request::Ping);
+        let tc = create_stm32h7_tc(&embedded_models::stm32h7::Request::Ping);
         log::info!(
             "Sending ping request with TC ID: {:#010x}",
             tc.ccsds_packet_id_and_psc().raw()
@@ -35,8 +49,8 @@ fn main() {
     }
 
     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);
+        let request = stm32h7::Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
+        let tc = create_stm32h7_tc(&request);
         log::info!(
             "Sending change blink frequency request {:?} with TC ID: {:#010x}",
             request,
@@ -50,11 +64,28 @@ fn main() {
         transport
             .receive(|packet: &[u8]| {
                 let reader = CcsdsPacketReader::new_with_checksum(packet);
-                log::info!("Received packet: {:?}", reader);
+                log::debug!("Received packet: {:?}", reader);
+                if let Ok(reader) = reader {
+                    let packet_data = reader.packet_data();
+                    let tm_header = postcard::take_from_bytes::<TmHeader>(&packet_data);
+                    if let Ok((tm_header, remainder)) = tm_header {
+                        let response = postcard::from_bytes::<stm32h7::Response>(remainder);
+                        if let Ok(response) = response {
+                            log::info!(
+                                "Received TM with header: {:?} and response: {:?}",
+                                tm_header,
+                                response
+                            );
+                        } else {
+                            log::error!("Failed to deserialize response: {:?}", response.err());
+                        }
+                    } else {
+                        log::error!("Failed to deserialize TM header: {:?}", tm_header.err());
+                    }
+                }
             })
             .unwrap();
     }
-    */
 }
 
 fn create_stm32h7_tc(request: &stm32h7::Request) -> CcsdsPacketCreatorOwned {

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

@@ -1,4 +1,4 @@
-use std::{fs::File, io::Read as _, path::Path, time::SystemTime};
+use std::{fs::File, io::Read as _, net::SocketAddr, path::Path, time::SystemTime};
 
 #[derive(Debug, serde::Deserialize)]
 pub struct Config {
@@ -7,7 +7,8 @@ pub struct Config {
 
 #[derive(Debug, serde::Deserialize)]
 pub struct Interface {
-    pub serial_port: String,
+    pub serial_port: Option<String>,
+    pub udp_addr: Option<SocketAddr>,
 }
 
 impl Config {
@@ -19,10 +20,10 @@ impl Config {
             .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| {
@@ -34,7 +35,7 @@ pub fn setup_logger() -> Result<(), fern::InitError> {
                 message
             ))
         })
-        .level(log::LevelFilter::Debug)
+        .level(log::LevelFilter::Info)
         .chain(std::io::stdout())
         .chain(fern::log_file("output.log")?)
         .apply()?;

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

@@ -327,9 +327,14 @@ mod app {
                     {
                         let response = match request {
                             stm32h7::Request::Ping => {
+                                defmt::info!("Received Ping request");
                                 stm32h7::Response::Ok
                             }
                             stm32h7::Request::ChangeBlinkFrequency(duration) => {
+                                defmt::info!(
+                                    "Received blinky frequency change request: {} ms",
+                                    duration.as_millis()
+                                );
                                 cx.shared.blink_freq.lock(|current| {
                                     *current = Duration::from_millis(duration.as_millis() as u64)
                                 });