First end-to-end movement

daemon/src/main.rs

@@ -1,7 +1,16 @@
 use anyhow::Result;
+use anyhow::{anyhow, Context};
+use axum::{
+    extract::State,
+    http::StatusCode,
+    routing::{get, post},
+    Json, Router,
+};
+use clap::Parser;
 use fern::colors::{Color, ColoredLevelConfig};
 use log::{debug, error, info, warn, Level};
 use serde_json::{json, Value};
+use std::time::Duration;
 use std::{borrow::Borrow, io};
 use tokio::{
     self,
@@ -10,13 +19,7 @@ use tokio::{
     sync::{mpsc, watch},
     task::JoinSet,
 };
-
-use axum::{
-    extract::State,
-    http::StatusCode,
-    routing::{get, post},
-    Json, Router,
-};
+use tokio_serial;
 use tower_http::{
     services::{ServeDir, ServeFile},
     trace::TraceLayer,
@@ -86,16 +89,61 @@ struct AxumAppState {
     pos_rx: watch::Receiver<(f32, f32)>,
 }
 
+#[derive(Parser)]
+struct Cli {
+    /// The usb serial number of the radom-controller
+    #[arg(short, long)]
+    serialnumber: String,
+
+    /// Listen address for the webserver
+    #[arg(short, long, default_value = "0.0.0.0:8000")]
+    web_listen_address: String,
+
+    /// Listen address for rotctl
+    #[arg(short, long, default_value = "0.0.0.0:1337")]
+    rotctl_listen_address: String,
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     setup_logger()?;
 
+    let args = Cli::parse();
+
+    let ports = tokio_serial::available_ports().unwrap_or(Vec::<serialport::SerialPortInfo>::new());
+
+    let mut radom_port: Option<String> = None;
+    for port in ports {
+        match port.port_type {
+            serialport::SerialPortType::UsbPort(usb_port_info) => {
+                match usb_port_info.serial_number {
+                    Some(serial) => {
+                        debug!("Found a serial port with: {}", serial);
+                        if serial == args.serialnumber {
+                            radom_port = Some(port.port_name.to_owned());
+                            info!("Found radom-controller as {}", port.port_name)
+                        }
+                    }
+                    None => continue,
+                }
+            }
+            _ => continue,
+        }
+    }
+
+    let radom_port = match radom_port {
+        Some(port) => port,
+        _ => {
+            return Err(anyhow!("No matching port found."));
+        }
+    };
+
     let (cmd_tx, cmd_rx) = mpsc::channel::<Command>(16);
     let (pos_tx, pos_rx) = watch::channel::<(f32, f32)>((0.0, 0.0));
 
     let mut tasks = JoinSet::new();
 
-    tasks.spawn(async move { control_rotor(cmd_rx, pos_tx).await });
+    tasks.spawn(async move { control_rotor(cmd_rx, pos_tx, radom_port).await });
 
     let state = AxumAppState {
         pos_rx: pos_rx.clone(),
@@ -108,14 +156,14 @@ async fn main() -> Result<()> {
             .with_state(state)
             .layer(TraceLayer::new_for_http());
 
-        let listener = tokio::net::TcpListener::bind("0.0.0.0:8000").await?;
+        let listener = tokio::net::TcpListener::bind(args.web_listen_address).await?;
         axum::serve(listener, app).await?;
 
         Ok(())
     });
 
     tasks.spawn(async move {
-        let listener = TcpListener::bind("127.0.0.1:1337").await?;
+        let listener = TcpListener::bind(args.rotctl_listen_address).await?;
 
         loop {
             let (socket, _) = listener.accept().await?;