ping request is arriving

satrs-example/client/Cargo.toml

@@ -9,3 +9,10 @@ log = "0.4"
 fern = "0.7"
 humantime = "2"
 satrs-example = { path = ".." }
+models = { path = "../models" }
+spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
+bitbybit = "1.4"
+arbitrary-int = "2"
+ctrlc = { version = "3.5" }
+postcard = { version = "1" }
+anyhow = "1"

satrs-example/client/src/main.rs

@@ -1,9 +1,16 @@
+use anyhow::bail;
+use arbitrary_int::u11;
 use clap::Parser as _;
+use models::{Apid, TcHeader};
 use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
+use spacepackets::{CcsdsPacketReader, SpacePacketHeader};
 use std::{
     net::{IpAddr, SocketAddr, UdpSocket},
-    sync::{Arc, atomic::AtomicBool},
-    time::SystemTime,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::{Duration, SystemTime},
 };
 
 #[derive(clap::Parser)]
@@ -30,13 +37,80 @@ fn setup_logger(level: log::LevelFilter) -> Result<(), fern::InitError> {
     Ok(())
 }
 
-fn main() {
+fn main() -> anyhow::Result<()> {
     setup_logger(log::LevelFilter::Debug).unwrap();
     let kill_signal = Arc::new(AtomicBool::new(false));
+    let ctrl_kill_signal = kill_signal.clone();
+    ctrlc::set_handler(move || ctrl_kill_signal.store(true, Ordering::Relaxed)).unwrap();
     let cli = Cli::parse();
 
     let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
     let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
+    client.set_nonblocking(true)?;
+    client.set_read_timeout(Some(Duration::from_millis(200)))?;
 
-    if cli.ping {}
+    if cli.ping {
+        log::info!("sending ping request");
+        let request = models::ccsds::CcsdsTcPacketOwned::new_with_request(
+            SpacePacketHeader::new_from_apid(u11::new(Apid::Tmtc as u16)),
+            TcHeader::new(models::ComponentId::Controller, models::MessageType::Ping),
+            models::request::Request::Ping,
+        );
+        let request_packet = request.to_vec();
+        client.send_to(&request_packet, addr).unwrap();
+    }
+
+    let mut recv_buf: Box<[u8; 2048]> = Box::new([0; 2048]);
+    loop {
+        if kill_signal.load(std::sync::atomic::Ordering::Relaxed) {
+            log::info!("received kill signal, exiting");
+            break;
+        }
+        match client.recv(recv_buf.as_mut_slice()) {
+            Ok(received_bytes) => handle_raw_tm_packet(&recv_buf.as_slice()[0..received_bytes])?,
+            Err(e) => {
+                if e.kind() == std::io::ErrorKind::WouldBlock
+                    || e.kind() == std::io::ErrorKind::TimedOut
+                {
+                    continue;
+                }
+                log::warn!("UDP reception error: {}", e)
+            }
+        }
+    }
+    Ok(())
+}
+
+fn handle_raw_tm_packet(data: &[u8]) -> anyhow::Result<()> {
+    match spacepackets::CcsdsPacketReader::new_with_checksum(data) {
+        Ok(packet) => {
+            let (tm_header, response, remainder) = unpack_tm_header_and_response(&packet)?;
+            log::info!(
+                "Received TM with APID {} and TM header {:?}",
+                packet.apid(),
+                tm_header
+            );
+            log::info!("Response: {:?} with remainder: {:?} ", response, remainder);
+        }
+        Err(_) => todo!(),
+    }
+    Ok(())
+}
+
+fn unpack_tm_header_and_response<'a>(
+    packet: &'a CcsdsPacketReader,
+) -> anyhow::Result<(models::TmHeader, models::response::Response, &'a [u8])> {
+    let tm_header_result = postcard::take_from_bytes::<models::TmHeader>(packet.user_data());
+    if let Err(e) = tm_header_result {
+        bail!("Failed to deserialize TM header: {}", e);
+    }
+    let (tm_header, remainder) = tm_header_result.unwrap();
+    log::info!("TM header: {:?}", tm_header);
+    let response_result = postcard::take_from_bytes::<models::response::Response>(remainder);
+    if let Err(e) = response_result {
+        bail!("Failed to deserialize TM header: {}", e);
+    }
+    let response = response_result.unwrap();
+    log::info!("Response: {:?}", response);
+    Ok((tm_header, response.0, response.1))
 }