Connect to bambu printers

1 files changed, 55 insertions, 10 deletions

diff --git a/src/main.rs b/src/main.rs
index 3b1c7f4..11a2e43 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,7 @@
+use native_tls::TlsConnector;
 use printstats::*;
-use rumqttc::{AsyncClient, Event, MqttOptions, Packet, QoS};
+use reqwest::Client;
+use rumqttc::{AsyncClient, Event, MqttOptions, Packet, QoS, Transport};
 use std::collections::HashMap;
 use std::fs;
 use std::sync::Arc;
@@ -14,20 +16,50 @@ async fn main() {
 
     for printer in config.printers {
         match printer {
-            Printer::Prusa { name, host, .. } => {
-                println!("Found Prusa: {} at {}", name, host);
+            Printer::Prusa { name, host, api_key, .. } => {
+                let state_clone = state.clone();
+                tokio::spawn(async move {
+                    let client = Client::new();
+                    let response = client.get(format!("http://{}", host))
+                        .header("X-Api-Key", api_key)
+                        .send()
+                        .await
+                        .unwrap()
+                        .json::<serde_json::Value>()
+                        .await
+                        .unwrap();
+                    let mut lock = state_clone.lock().await;
+                    println!("{:?}", &response);
+                    /*
+                    if let Ok(msg) = serde_json::from_slice::<BambuMessage>(&p.payload) {
+                        lock.entry(name.clone())
+                            .and_modify(|prs| prs.bed_temp = msg.print.bed_temper)
+                            .or_insert_with(|| PrinterState { name: name.clone(), bed_temp: msg.print.bed_temper, ..Default::default() });
+                        println!("Updated state for {}: {:?}", &name, p.payload);
+                    }
+                    */
+                    println!("Found Prusa: {} at {}", name, host);
+                });
             }
             Printer::Bambu {
                 name,
                 host,
                 serial_number,
-                ..
+                access_code,
             } => {
                 println!("Found Bambu: {} at {}", name, host);
                 let state_clone = Arc::clone(&state);
                 tokio::spawn(async move {
-                    let mut mqttoptions = MqttOptions::new(name, host, 1883);
+                    let mut mqttoptions = MqttOptions::new(&name, &host, 8883);
                     mqttoptions.set_keep_alive(Duration::from_secs(5));
+                    mqttoptions.set_credentials("bblp", &access_code);
+
+                    // Bambu printers use TLS with a self-signed certificate
+                    let connector = TlsConnector::builder()
+                        .danger_accept_invalid_certs(true)
+                        .build()
+                        .unwrap();
+                    mqttoptions.set_transport(Transport::tls_with_config(connector.into()));
 
                     let (client, mut eventloop) = AsyncClient::new(mqttoptions, 10);
                     client
@@ -41,11 +73,17 @@ async fn main() {
                             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);
+                                    println!("{:?}", &p.payload);
+                                    if let Ok(msg) = serde_json::from_slice::<BambuMessage>(&p.payload) {
+                                        lock.entry(name.clone())
+                                            .and_modify(|prs| prs.bed_temp = msg.print.bed_temper)
+                                            .or_insert_with(|| PrinterState { name: name.clone(), bed_temp: msg.print.bed_temper, ..Default::default() });
+                                        println!("Updated state for {}: {:?}", &name, p.payload);
+                                    }
                                 }
                             }
-                            Err(_) => {
+                            Err(e) => {
+                                eprintln!("MQTT error: {:?}", e);
                                 tokio::time::sleep(Duration::from_secs(5)).await; // Simple retry
                             }
                         }
@@ -56,8 +94,15 @@ async fn main() {
     }
 
     loop {
-        print!("\x1B[2J\x1B[1;1H"); // clear screen
+        let state_clone = Arc::clone(&state);
+        println!("-- PRINTER STATE --");
+
+        let lock = state_clone.lock().await;
+
+        for (key, value) in lock.iter() {
+            println!("{}: {:?}", key, value);
+        }
 
-        std::thread::sleep(Duration::from_secs(5));
+        tokio::time::sleep(Duration::from_secs(1)).await;
     }
 }