3D-Druck/OctoPrint-BambuPrinter
1
0
Fork 0
Code Pull Requests Actions 1 Packages Releases 1 Activity

Verbessere die Verarbeitung von MQTT-Nachrichten in BambuVirtualPrinter mit zentraler Payload-Verarbeitung, erweitere Fehlerbehandlung und aktualisiere Temperatur- sowie Druckerstatusmethoden.

Browse Source
This commit is contained in:
Manuel Weiser
2025-03-02 11:23:32 +01:00
parent ad08d3eb9a
commit 61c9332f15
1 changed files with 109 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
octoprint_bambu_printer/printer/bambu_virtual_printer.py
View File

@@ -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()