diff --git a/octoprint_bambu_printer/printer/bambu_virtual_printer.py b/octoprint_bambu_printer/printer/bambu_virtual_printer.py index 99b057e..736417f 100644 --- a/octoprint_bambu_printer/printer/bambu_virtual_printer.py +++ b/octoprint_bambu_printer/printer/bambu_virtual_printer.py @@ -274,91 +274,120 @@ class BambuVirtualPrinter: payload = json.loads(msg.payload.decode('utf-8')) self._log.debug(f"MQTT message received on topic {msg.topic}: {list(payload.keys())}") - # Vollständigen Payload für Debugging ausgeben - self._log.debug(f"Full MQTT payload: {json.dumps(payload)}") + # Direkte Verarbeitung der Daten + self._process_mqtt_payload(payload) - # Verarbeite direkt die Daten aus der MQTT-Nachricht - if 'print' in payload: - self._log.info(f"Processing print data with keys: {list(payload['print'].keys())}") - self._process_print_data(payload['print']) + # Auch an Bambu Client weiterleiten + try: + # Wenn der BambuClient eine eigene Verarbeitungsmethode hat, nutzen wir diese + if hasattr(self._bambu_client, '_process_message') and callable(self._bambu_client._process_message): + self._bambu_client._process_message(msg.topic, payload) + self._log.debug("Message forwarded to pybambu via _process_message") + elif hasattr(self._bambu_client, '_handle_mqtt_message') and callable(self._bambu_client._handle_mqtt_message): + self._bambu_client._handle_mqtt_message(client, userdata, msg) + self._log.debug("Message forwarded to pybambu via _handle_mqtt_message") + else: + # Wenn keine Methode zur Verarbeitung verfügbar ist, aktualisieren wir die Datenstruktur manuell + self._log.debug("No message handler found in BambuClient, updating state manually") + self._update_bambu_client_state(payload) + except Exception as e: + self._log.error(f"Error forwarding to pybambu: {e}", exc_info=True) - # Forward the message to pybambu for its internal state - try: - if hasattr(self._bambu_client, '_process_message'): - self._bambu_client._process_message(msg.topic, payload) - self._log.debug("Message forwarded to pybambu via _process_message") - else: - # Alternative Methode für pybambu - self._update_bambu_client_state(payload) - self._log.debug("Message processed via _update_bambu_client_state") - except Exception as e: - self._log.error(f"Error forwarding to pybambu: {e}") - - # Trigger explicit update of printer info after processing print data - self._log.debug("Triggering printer data update") - self.new_update("event_printer_data_update") - - if 'info' in payload: - self._log.info(f"Processing info data with keys: {list(payload['info'].keys())}") - if 'hms' in payload['info']: - # Aktualisiere HMS-Fehler direkt - try: - if hasattr(self._bambu_client.device, 'hms'): - self._bambu_client.device.hms.update_from_payload(payload['info']['hms']) - self._log.debug("HMS error data updated") - except Exception as e: - self._log.error(f"Error updating HMS data: {e}") - self._log.debug("Triggering HMS errors update") - self.new_update("event_hms_errors") except Exception as e: self._log.error(f"Error processing MQTT message: {e}", exc_info=True) - def _process_print_data(self, print_data): - """Verarbeitet direkt die Druckerdaten aus der MQTT-Nachricht""" + def _process_mqtt_payload(self, payload): + """Zentrale Methode zur Verarbeitung von MQTT-Payloads""" try: - # Aktualisiere Temperaturdaten direkt - if 'temperature' in print_data: - temp_data = print_data['temperature'] + # Verarbeite print-Daten + if 'print' in payload: + print_data = payload['print'] + self._log.info(f"Processing print data with keys: {list(print_data.keys())}") - # Extruder Temperatur - if 'nozzle_temp' in temp_data: - self._telemetry.temp[0] = float(temp_data['nozzle_temp']) - if 'target_nozzle_temp' in temp_data: - self._telemetry.targetTemp[0] = float(temp_data['target_nozzle_temp']) - - # Bett Temperatur - if 'bed_temp' in temp_data: - self._telemetry.bedTemp = float(temp_data['bed_temp']) - if 'target_bed_temp' in temp_data: - self._telemetry.bedTargetTemp = float(temp_data['target_bed_temp']) - - # Kammer Temperatur - if 'chamber_temp' in temp_data: - self._telemetry.chamberTemp = float(temp_data['chamber_temp']) + # Temperaturdaten verarbeiten + if 'temperature' in print_data: + self._process_temperature_data(print_data['temperature']) - self._log.debug(f"Updated temperatures - Nozzle: {self._telemetry.temp[0]}/{self._telemetry.targetTemp[0]}, " + - f"Bed: {self._telemetry.bedTemp}/{self._telemetry.bedTargetTemp}, " + - f"Chamber: {self._telemetry.chamberTemp}") + # Status verarbeiten + if 'gcode_state' in print_data: + self._process_print_state(print_data['gcode_state']) + + # Trigger update + self.new_update("event_printer_data_update") - # Aktualisiere Druckerstatus - if 'gcode_state' in print_data: - print_job_state = print_data['gcode_state'] - self._log.debug(f"Received printer state update: {print_job_state}") + # Verarbeite info-Daten + if 'info' in payload: + info_data = payload['info'] + self._log.info(f"Processing info data with keys: {list(info_data.keys())}") - if print_job_state in ["IDLE", "FINISH", "FAILED"]: - self.change_state(self._state_idle) - elif print_job_state in ["RUNNING", "PREPARE"]: - self.change_state(self._state_printing) - elif print_job_state == "PAUSE": - self.change_state(self._state_paused) - else: - self._log.warn(f"Unknown print job state: {print_job_state}") - - # Aktualisiere auch die pybambu-Datenstruktur - if hasattr(self._bambu_client, 'device') and hasattr(self._bambu_client.device, 'print_job'): - self._bambu_client.device.print_job.gcode_state = print_job_state + # HMS-Fehler verarbeiten + if 'hms' in info_data: + self._process_hms_errors(info_data['hms']) + self.new_update("event_hms_errors") except Exception as e: - self._log.error(f"Error processing print data: {e}") + self._log.error(f"Error processing MQTT payload: {e}", exc_info=True) + + def _process_temperature_data(self, temp_data): + """Verarbeitet Temperaturdaten aus MQTT-Nachrichten""" + try: + # Extruder Temperatur + if 'nozzle_temp' in temp_data: + self._telemetry.temp[0] = float(temp_data['nozzle_temp']) + if 'target_nozzle_temp' in temp_data: + self._telemetry.targetTemp[0] = float(temp_data['target_nozzle_temp']) + + # Bett Temperatur + if 'bed_temp' in temp_data: + self._telemetry.bedTemp = float(temp_data['bed_temp']) + if 'target_bed_temp' in temp_data: + self._telemetry.bedTargetTemp = float(temp_data['target_bed_temp']) + + # Kammer Temperatur + if 'chamber_temp' in temp_data: + self._telemetry.chamberTemp = float(temp_data['chamber_temp']) + + self._log.debug(f"Updated temperatures - Nozzle: {self._telemetry.temp[0]}/{self._telemetry.targetTemp[0]}, " + + f"Bed: {self._telemetry.bedTemp}/{self._telemetry.bedTargetTemp}, " + + f"Chamber: {self._telemetry.chamberTemp}") + except Exception as e: + self._log.error(f"Error processing temperature data: {e}", exc_info=True) + + def _process_print_state(self, print_job_state): + """Verarbeitet den Druckerstatus aus MQTT-Nachrichten""" + try: + self._log.debug(f"Received printer state update: {print_job_state}") + + if print_job_state in ["IDLE", "FINISH", "FAILED"]: + self.change_state(self._state_idle) + elif print_job_state in ["RUNNING", "PREPARE"]: + self.change_state(self._state_printing) + elif print_job_state == "PAUSE": + self.change_state(self._state_paused) + else: + self._log.warn(f"Unknown print job state: {print_job_state}") + + # Aktualisiere auch die pybambu-Datenstruktur + if hasattr(self._bambu_client, 'device') and hasattr(self._bambu_client.device, 'print_job'): + self._bambu_client.device.print_job.gcode_state = print_job_state + except Exception as e: + self._log.error(f"Error processing print state: {e}", exc_info=True) + + def _process_hms_errors(self, hms_data): + """Verarbeitet HMS-Fehlerdaten aus MQTT-Nachrichten""" + try: + if hasattr(self._bambu_client, 'device') and hasattr(self._bambu_client.device, 'hms'): + self._bambu_client.device.hms.update_from_payload(hms_data) + self._log.debug("HMS error data updated") + + # Überprüfe auf Fehler und zeige sie an + if self._bambu_client.device.hms.errors != self._last_hms_errors and self._bambu_client.device.hms.errors["Count"] > 0: + self._log.debug(f"HMS Error: {self._bambu_client.device.hms.errors}") + for n in range(1, self._bambu_client.device.hms.errors["Count"] + 1): + error = self._bambu_client.device.hms.errors[f"{n}-Error"].strip() + self.sendIO(f"// action:notification {error}") + self._last_hms_errors = self._bambu_client.device.hms.errors + except Exception as e: + self._log.error(f"Error processing HMS errors: {e}", exc_info=True) def _update_bambu_client_state(self, payload): """Aktualisiert die internen Zustände des BambuClient""" @@ -422,11 +451,13 @@ class BambuVirtualPrinter: auth_token=self._settings.get(["auth_token"]), ) - # Initialisiere den BambuClient hier, bevor wir die MQTT-Verbindung herstellen + # Initialisiere die device-Eigenschaft manuell, wenn sie nicht vorhanden ist if not hasattr(bambu_client, 'device'): - self._log.debug("Initializing BambuClient device attribute") - # Stellen Sie sicher, dass wir den Client nur initialisieren, wenn er existiert - bambu_client._init_device() + self._log.debug("BambuClient has no device attribute, creating it manually") + # Anstatt die nicht existierende _init_device Methode zu verwenden, + # initialisieren wir den Client mit einer Verbindung, die später durch unsere ersetzt wird + bambu_client.connect() + bambu_client.disconnect() # Trennen Sie die automatische Verbindung sofort wieder # Set up our own MQTT client self._mqtt_client = mqtt.Client()