Get sync jogger working

red/src/jogger.rs

@@ -34,11 +34,12 @@ pub struct PrinterUnits;
 pub type PrinterVec = Vector3D<f64, PrinterUnits>;
 
 /// Jog the gantry by pumping loads of gcode into the printer board
-pub async fn jog<T: AsyncRead + AsyncWrite + Sized>(gamepad: Arc<Mutex<Gamepad>>, mut printer: Printer) -> Never {
+pub fn jog(gamepad: &mut Gamepad, mut printer: Printer) -> Never {
     printer.use_absolute_movements().unwrap();
     println!("Using absolute movements");
     loop {
-        let (setpoint_x, setpoint_y, setpoint_z) = gamepad.lock().unwrap().deref_mut().speed_setpoint(&[]);
+        let events = gamepad.get_pending();
+        let (setpoint_x, setpoint_y, setpoint_z) = gamepad.speed_set_point(&events);
 
         let distance: PrinterVec = vec3(
             FULL_SCALE_SPEED_XY * (TIME_PER_MOVEMENT.as_secs_f64() / 60.0) * (setpoint_x as f64),
@@ -46,11 +47,11 @@ pub async fn jog<T: AsyncRead + AsyncWrite + Sized>(gamepad: Arc<Mutex<Gamepad>>
             FULL_SCALE_SPEED_Z * (TIME_PER_MOVEMENT.as_secs_f64() / 60.0) * (setpoint_z as f64),
         );
         if distance.length() == 0.0 {
-            sleep(TIME_PER_MOVEMENT).await;
+            std::thread::sleep(TIME_PER_MOVEMENT);
             continue;
         }
         let velocity = distance.length() / (TIME_PER_MOVEMENT.as_secs_f64() / 60.0);
-        let old_postion = (*printer.state.lock().unwrap()).position;
+        let old_postion = printer.state.lock().unwrap().position;
         printer
             .move_absolute(
                 old_postion.x + distance.x,
@@ -70,9 +71,9 @@ pub async fn jog<T: AsyncRead + AsyncWrite + Sized>(gamepad: Arc<Mutex<Gamepad>>
         println!("fill level: {}", fill_level);
         match fill_level.cmp(&TARGET_BUFER_FILL_LEVEL) {
             std::cmp::Ordering::Equal => {
-                sleep(LONG_COMMAND_DELAY / SHORT_COMMAND_DELAY_DIVIDER).await
+                std::thread::sleep(LONG_COMMAND_DELAY / SHORT_COMMAND_DELAY_DIVIDER)
             }
-            std::cmp::Ordering::Greater => sleep(LONG_COMMAND_DELAY).await,
+            std::cmp::Ordering::Greater => std::thread::sleep(LONG_COMMAND_DELAY),
             _ => {}
         }
     }

red/src/main.rs

@@ -1,12 +1,46 @@
 #![warn(rust_2018_idioms)]
 
-use red::printer::Printer;
-use std::path::Path;
 use futures::never::Never;
+use red::gamepad::Gamepad;
+use red::printer::Printer;
+use red::jogger;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
 use tokio_serial::SerialPortInfo;
 
 fn main() -> Never {
-    look_for_printer()
+    jog()
+}
+
+fn jog() -> Never {
+    let mut gamepad = Gamepad::new().expect("Failed to open gamepad");
+    
+    println!("Entering App");
+    let serial_ports = tokio_serial::available_ports()
+        .expect("Could not list serial ports")
+        .into_iter()
+        .filter(|port| port.port_name.contains("ttyUSB"))
+        .collect::<Vec<SerialPortInfo>>();
+    let port = match serial_ports.len() {
+        1 => serial_ports.to_owned().pop().unwrap(),
+        0 => panic!("No USB serial port found! Is the green board disconnected or turned off?"),
+        _ => panic!("There are multiple USB serial ports and we have no way to check which one is the Marlin board!")
+    };
+    let port_path = Path::new("/dev").join(Path::new(&port.port_name).file_name().unwrap());
+    println!("Found serial port: {:?}", &port_path);
+    
+    let printer = Printer::connect_to_path(&port_path.as_os_str().to_string_lossy()).unwrap();
+    
+    jogger::jog(&mut gamepad, printer)
+}
+
+fn print_gamepad_events() -> Never {
+    let mut gamepad = Gamepad::new().expect("Failed to open gamepad");
+    loop {
+        let events = gamepad.get_pending();
+        println!("speed setpoint: {:?}", gamepad.speed_set_point(&events));
+        std::thread::sleep(std::time::Duration::from_millis(500));
+    }
 }
 
 fn look_for_printer() -> Never {
@@ -23,7 +57,14 @@ fn look_for_printer() -> Never {
     };
     let port_path = Path::new("/dev").join(Path::new(&port.port_name).file_name().unwrap());
     println!("Found serial port: {:?}", &port_path);
-    let printer = Printer::connect_to_path(&port_path.as_os_str().to_string_lossy()).unwrap();
+    let mut printer = Printer::connect_to_path(&port_path.as_os_str().to_string_lossy()).unwrap();
+    printer
+        .move_relative(10., 0., 0., None)
+        .expect("Could not move printer head");
+    println!("{:?}", printer.printer_state());
+    printer
+        .move_relative(-10., 0., 0., None)
+        .expect("Could not move printer head");
     loop {
         println!("{:?}", printer.printer_state());
         std::thread::sleep(std::time::Duration::from_millis(1000));