Initial commit

1 files changed, 63 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..7660108
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,63 @@
+use printstats::*;
+use rumqttc::{AsyncClient, Event, MqttOptions, Packet, QoS};
+use std::collections::HashMap;
+use std::fs;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::Mutex;
+
+#[tokio::main]
+async fn main() {
+    let content = fs::read_to_string("config.toml").expect("Couldn't read config.toml");
+    let config: Config = toml::from_str(&content).expect("Couldn't parse config.toml");
+    let state = Arc::new(Mutex::new(HashMap::<String, PrinterState>::new()));
+
+    for printer in &config.printers {
+        match printer {
+            Printer::Prusa { name, host, .. } => {
+                println!("Found Prusa: {} at {}", name, host);
+            }
+            Printer::Bambu {
+                name,
+                host,
+                serial_number,
+                ..
+            } => {
+                println!("Found Bambu: {} at {}", name, host);
+                let state_clone = Arc::clone(&state);
+                tokio::spawn(async move {
+                    let mut mqttoptions = MqttOptions::new(name, host, 1883);
+                    mqttoptions.set_keep_alive(Duration::from_secs(5));
+
+                    let (client, mut eventloop) = AsyncClient::new(mqttoptions, 10);
+                    client
+                        .subscribe(format!("device/{}/report", serial_number), QoS::AtMostOnce)
+                        .await
+                        .unwrap();
+
+                    loop {
+                        // eventloop.poll() yields back to Tokio when there's no data
+                        match eventloop.poll().await {
+                            Ok(notification) => {
+                                if let Event::Incoming(Packet::Publish(p)) = notification {
+                                    let mut lock = state_clone.lock().await;
+                                    // TODO - Update struct
+                                    println!("Updated state from {:?}", p.payload);
+                                }
+                            }
+                            Err(_) => {
+                                tokio::time::sleep(Duration::from_secs(5)).await; // Simple retry
+                            }
+                        }
+                    }
+                });
+            }
+        }
+    }
+
+    loop {
+        print!("\x1B[2J\x1B[1;1H"); // clear screen
+
+        std::thread::sleep(Duration::from_secs(5));
+    }
+}