add more fields to bambu status

2 files changed, 55 insertions, 21 deletions

diff --git a/src/lib.rs b/src/lib.rs
index a49aba0..7c2aea7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -30,6 +30,16 @@ pub enum PrusaState {
 }
 
 #[derive(Debug, Deserialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum BambuState {
+    Idle,
+    Running,
+    Pause,
+    Finish,
+    Failed,
+}
+
+#[derive(Debug, Deserialize)]
 pub struct PrusaJob {
     pub id: u32,
     pub progress: f32,
@@ -60,13 +70,22 @@ pub struct PrusaStatus {
 }
 
 #[derive(Deserialize)]
-pub struct BambuState {
-    pub bed_temper: f32,
+pub struct BambuPrintMessage {
+    pub bed_target_temper: Option<f32>,
+    pub bed_temper: Option<f32>,
+    pub gcode_state: Option<BambuState>,
+    pub layer_num: Option<u32>,
+    pub mc_percent: Option<u32>,
+    pub mc_remaining_time: Option<u32>,
+    pub nozzle_target_temper: Option<f32>,
+    pub nozzle_temper: Option<f32>,
+    pub print_speed: Option<String>,
+    pub total_layer_num: Option<u32>,
 }
 
 #[derive(Deserialize)]
-pub struct BambuMessage {
-    pub print: BambuState,
+pub struct BambuStatus {
+    pub print: Option<BambuPrintMessage>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -97,13 +116,30 @@ pub enum Printer {
     },
 }
 
-pub fn extract_status_from_prusa(status: &PrusaStatus) -> PrinterState {
-    let print_status = match status.printer.state {
+pub fn extract_status_from_prusa(status: &PrusaStatus, state: &mut PrinterState) {
+    state.status = match status.printer.state {
         PrusaState::Idle => PrintStatus::Idle,
         PrusaState::Printing => PrintStatus::Printing,
         PrusaState::Paused => PrintStatus::Paused,
         PrusaState::Finished => PrintStatus::Finished,
         _ => PrintStatus::Unknown,
     };
-    PrinterState { bed_temp: status.printer.temp_bed, status: print_status }
-}
\ No newline at end of file
+    state.bed_temp = status.printer.temp_bed;
+}
+
+pub fn extract_status_from_bambu(status: &BambuStatus, state: &mut PrinterState) {
+    if let Some(print) = &status.print {
+        if let Some(bed_temper) = print.bed_temper {
+            state.bed_temp = bed_temper;
+        }
+        if let Some(gcode_state) = &print.gcode_state {
+            state.status = match gcode_state {
+                BambuState::Idle => PrintStatus::Idle,
+                BambuState::Running => PrintStatus::Printing,
+                BambuState::Pause => PrintStatus::Paused,
+                BambuState::Finish => PrintStatus::Finished,
+                _ => PrintStatus::Unknown,
+            };
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 5dc84eb..29df56d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -35,9 +35,8 @@ async fn main() {
                                 .json::<PrusaStatus>()
                                 .await?;
                             let mut lock = state_clone.lock().await;
-                            lock.entry(name.clone())
-                                .and_modify(|prs| *prs = extract_status_from_prusa(&response))
-                                .or_insert_with(|| { extract_status_from_prusa(&response) } );
+                            let entry = lock.entry(name.clone()).or_default();
+                            extract_status_from_prusa(&response, entry);
                             Ok(())
                         }
                         .await;
@@ -81,16 +80,15 @@ async fn main() {
                                 if let Event::Incoming(Packet::Publish(p)) = notification {
                                     let mut lock = state_clone.lock().await;
                                     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 {
-                                                bed_temp: msg.print.bed_temper,
-                                                ..Default::default()
-                                            });
-                                        println!("Updated state for {}: {:?}", &name, p.payload);
+                                    match serde_json::from_slice::<BambuStatus>(&p.payload) {
+                                        Ok(msg) => {
+                                            let entry = lock.entry(name.clone()).or_default();
+                                            extract_status_from_bambu(&msg, entry);
+                                            println!("Updated state for {}: {:?}", &name, p.payload);
+                                        }
+                                        Err(e) => {
+                                            eprintln!("Failed to deserialize BambuStatus: {}", e);
+                                        }
                                     }
                                 }
                             }