Fixes & Enhancements for Client Demo

Fixes & Enhancements for Client Demo

Author: DeviPriya-Kolla

relay/src/main.rs

@@ -20,7 +20,9 @@ use interprocess::local_socket::{
 };
 
 fn main() -> iced::Result {
-    let (tx, rx) = std::sync::mpsc::channel();
+    let (tx_kill, rx_kill) = std::sync::mpsc::channel();
+
+    let (txx, rxx) = std::sync::mpsc::channel();
     // let _ = tx.send(()); // temp
     let handle = thread::spawn(move || {
         // sample pulled directly from `interprocess` documentation
@@ -49,7 +51,7 @@ fn main() -> iced::Result {
         let mut buffer = String::with_capacity(128);
 
         for conn in listener.incoming() {
-            let conn = match (rx.try_recv(), conn) {
+            let conn = match (rx_kill.try_recv(), conn) {
                 (Ok(()), _) => return,
                 (_, Ok(c)) => {
                     println!("success");
@@ -100,54 +102,59 @@ fn main() -> iced::Result {
                     _ => break,
                 };
                 match conn.read_line(&mut buffer) {
-                    Ok(0) => continue,
+                    /* Ok(0) => {
+                        println!("Termination signal received from baton");
+                        continue;
+                    } */
                     Ok(_) => recvs[idx] += 1,
                     Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
                     _ => panic!(),
                 }
             }
 
             println!("recvs: {recvs:?}");
+            buffer.clear();
 
-            // one minute of receiving test data from the plugin
-            println!("Beginning 1MIN_RECV test...");
-            let start = std::time::Instant::now();
+            // Continuously receive data from plugin
             loop {
-                let elapsed = start.elapsed();
-                if elapsed >= Duration::from_secs(60) {
-                    break;
-                }
-
                 // TODO: Create display in GUI for this instead of printing to stdout. Just doing this for ease for the
                 // demo for the time being.
                 match conn.read_line(&mut buffer) {
-                    Ok(0) => {
-                        println!(
-                            "Other end terminated connection after {elapsed:?}. Test complete!"
-                        );
-                        break;
+                    Ok(s) if s == 0 || buffer.len() == 0 => {
+                        buffer.clear();
+                        continue;
+                    }
+                    Ok(s) => {
+                        // remove trailing newline
+                        let _ = buffer.pop();
+
+                        // display
+                        println!("Got: {buffer} ({s} bytes read)");
+
+                        if let Ok(num) = buffer.parse::<f32>() {
+                            let _ = txx.send(num);
+                        }
+                        buffer.clear();
                     }
-                    Ok(s) => println!("Got: {buffer} ({s} bytes)"),
                     Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
                     Err(e) => panic!("Got err {e}"),
                 }
             }
-            println!("1MIN_RECV test complete!");
-
-            break;
         }
     });
 
     iced::application("RELAY", update, view)
+        .window_size((250.0, 100.0))
         .exit_on_close_request(false)
         .subscription(subscribe)
         .run_with(|| {
             // for pre-run state initialization
             let state = State {
                 elapsed_time: Duration::ZERO,
-                flicker: false,
                 thread_handle: Some(handle),
-                tx: Some(tx),
+                tx_kill: Some(tx_kill),
+                rx_baton: Some(rxx),
+                latest_baton_send: None,
             };
             (state, Task::none())
         })
@@ -156,13 +163,16 @@ fn main() -> iced::Result {
 fn subscribe(_state: &State) -> iced::Subscription<Message> {
     use Message as M;
 
+    // Subscription for displaying elapsed time -- temporary
     let time_sub = every(Duration::from_secs(1)).map(|_| M::Update);
-    let flicker_sub = every(Duration::from_millis(500)).map(|_| M::Flicker);
+
+    // Subscription to re-check the baton connection
+    let baton_sub = every(Duration::from_millis(10)).map(|_| M::BatonMessage);
 
     // Subscription to send a message when the window close button (big red X) is clicked.
     // Needed to execute cleanup operations before actually shutting down, such as saving etc
     let window_close = iced::window::close_requests().map(|id| M::WindowCloseRequest(id));
 
     // combine and return all subscriptions as one subscription to satisfy the return type
-    iced::Subscription::batch([time_sub, flicker_sub, window_close])
+    iced::Subscription::batch([time_sub, baton_sub, window_close])
 }

relay/src/message.rs

@@ -3,9 +3,9 @@ pub(crate) enum Message {
     // generic time update signal
     Update,
 
-    // for testing subscription batching, temporary
-    Flicker,
-
     // signal for pre-shutdown procedures and the ID for our window, which is to be closed
     WindowCloseRequest(iced::window::Id),
+
+    // signal to check the baton thread
+    BatonMessage,
 }

relay/src/state.rs

@@ -3,9 +3,11 @@ use std::thread::JoinHandle;
 use iced::time::Duration;
 
 #[derive(Default)]
+#[allow(unused)]
 pub(crate) struct State {
     pub elapsed_time: Duration,
-    pub flicker: bool,
     pub thread_handle: Option<JoinHandle<()>>,
-    pub tx: Option<std::sync::mpsc::Sender<()>>,
+    pub tx_kill: Option<std::sync::mpsc::Sender<()>>,
+    pub rx_baton: Option<std::sync::mpsc::Receiver<f32>>,
+    pub latest_baton_send: Option<f32>,
 }

relay/src/update.rs

@@ -11,13 +11,9 @@ pub(crate) fn update(state: &mut State, message: Message) -> Task<Message> {
             state.elapsed_time += Duration::from_secs(1);
             Task::none()
         }
-        M::Flicker => {
-            state.flicker = !state.flicker;
-            Task::none()
-        }
         M::WindowCloseRequest(id) => {
             // pre-shutdown operations go here
-            if let Some(ref tx) = state.tx {
+            if let Some(ref tx) = state.tx_kill {
                 let _ = tx.send(());
             }
 
@@ -37,6 +33,12 @@ pub(crate) fn update(state: &mut State, message: Message) -> Task<Message> {
             // necessary to actually shut down the window, otherwise the close button will appear to not work
             iced::window::close(id)
         }
+        M::BatonMessage => {
+            if let Some(num) = state.rx_baton.as_ref().and_then(|rx| rx.try_recv().ok()) {
+                state.latest_baton_send = Some(num);
+            }
+            Task::none()
+        }
         _ => Task::none(),
     }
 }

relay/src/view.rs

@@ -6,10 +6,14 @@ use iced::{
 use crate::{Message, State};
 
 pub(crate) fn view(state: &State) -> Element<Message> {
+    let baton_data = match state.latest_baton_send {
+        Some(num) => format!("[BATON] Pilot Elevation: {num:.3} ft"),
+        None => "No data from baton.".into(),
+    };
+
     column![
-        text("Hello, world."),
         text(format!("Elapsed time: {:?}", state.elapsed_time)),
-        text(format!("Flicker is: {}", state.flicker))
+        text(baton_data)
     ]
     .into()
 }

xplane_plugin/meson.build

@@ -74,7 +74,7 @@ lib = shared_library(
   # dependencies: [winsock, xplm, xpwidgets],
   include_directories: [inc_dir, lib_dir],
   cpp_args: compiler_args,
-  # link_args: ['-lntdll', '-static-libstdc++', '-static-libgcc', '-static'],
+  link_args: ['-lntdll', '-static-libstdc++', '-static-libgcc', '-static'],
   name_prefix: 'Pilot',
   name_suffix: 'xpl'
 )

xplane_plugin/src/pilotdatasync-xp11.cpp

@@ -483,6 +483,6 @@ void draw_pilotdatasync_plugin(XPLMWindowID in_window_id, void *in_refcon) {
                  NULL, xplmFont_Proportional);
 
   // BATON TEST
-  baton->send(currentPilotAirspeed);
+  baton->send(currentPilotElevation);
   //
 }

xplane_plugin/subprojects/baton/ali_log.txt

@@ -7,10 +7,9 @@ Keep in mind that what is shown here is not entirely typical of Rust code, as th
 in order to facilitate the aforementioned interoperability.
 */
 
-use crossbeam::channel::{unbounded, Receiver, Sender, TryRecvError};
+use crossbeam::channel::{unbounded, Receiver, Sender};
 use interprocess::local_socket::{
-    prelude::*, GenericFilePath, GenericNamespaced, ListenerNonblockingMode, NameType, Stream,
-    ToFsName,
+    prelude::*, GenericFilePath, GenericNamespaced, NameType, Stream, ToFsName,
 };
 use std::{
     io::{prelude::*, BufReader},
@@ -45,7 +44,7 @@ impl ThreadWrapper {
     pub fn start(&mut self) {
         // Rust does not have nulls. If you do not understand Options, read the Rust Book chapter 6.1
         let None = self.thread else {
-            // println!("Thread already started!");
+            println!("Thread already started!");
             return;
         };
 
@@ -80,44 +79,23 @@ impl ThreadWrapper {
             // like above because BufReader implemenets the Read Trait.
             conn.read_line(&mut buffer).unwrap();
 
-            // print!("[RUST] Server answered: {buffer}");
+            print!("[RUST] Server answered: {buffer}");
 
             // send a bunch of data for the frequency test in one-second intervals
             for _ in 0..3 {
-                for _ in 0..100000 {
-                    let _ = conn.get_mut().write_all(b"\n");
+                for _ in 0..5 {
+                    let _ = conn.get_mut().write_all(b"0\n");
                 }
                 std::thread::sleep(std::time::Duration::from_secs(1));
             }
 
-            let _ = conn.get_mut().flush();
-
-            /* loop {
-                match rx.try_recv() {
-                    Ok(ChannelSignal::Stop) => return,
-                    Ok(ChannelSignal::Send(n)) => {
-                        let _ = conn.get_mut().write_all(n.to_string().as_bytes());
-                    }
-                    Err(TryRecvError::Disconnected) => return,
-                    Err(TryRecvError::Empty) => thread::sleep(std::time::Duration::from_millis(50)),
-                }
-            } */
-
-            // 1MIN_RECV test
-            let start = std::time::Instant::now();
+            // Continuously send values
             loop {
-                if start.elapsed() >= std::time::Duration::from_secs(60) {
-                    break;
-                }
-
-                // dummy send
-                let _ = conn.get_mut().write_all(b"123\n");
-
                 for message in rx.try_iter() {
                     let _ = match message {
                         ChannelSignal::Send(n) => {
-                            let s = format!("{n}\n");
-                            conn.get_mut().write_all(s.as_bytes())
+                            let s: String = format!("{n}\n");
+                            let _ = conn.get_mut().write_all(s.as_bytes());
                         }
                         ChannelSignal::Stop => return,
                     };
@@ -130,10 +108,11 @@ impl ThreadWrapper {
 
     pub fn stop(&mut self) {
         let Some(handle) = self.thread.take() else {
-            // println!("[RUST] No currently running thread.");
+            println!("[RUST] No currently running thread.");
             return;
         };
 
+        println!("[RUST] Attempting to stop thread...");
         // Signal the thread to stop operations
         if let Some(tx) = &self.tx {
             let _ = tx.send(ChannelSignal::Stop);
@@ -142,12 +121,12 @@ impl ThreadWrapper {
         // Block until thread completes
         let _ = handle.join();
 
-        // println!("[RUST] Thread stopped successfully!");
+        println!("[RUST] Thread stopped successfully!");
         self.thread = None;
     }
 
     fn send(&mut self, num: f32) {
-        // println!("[RUST] Attempted to send {num:?}");
+        println!("[RUST] Attempted to send {num:?}");
         if let Some(tx) = &self.tx {
             let _ = tx.send(ChannelSignal::Send(num));
         }