"""BIQU Panda Breath chamber heater over MQTT (#1466). Firmware 1.0.4 added a Home Assistant binding: the device connects to an MQTT broker and, for a device id ````, uses panda_breath//state JSON document with every value panda_breath//availability "online" / "offline" panda_breath//command JSON object with the one value to change The keys and values below are the ones the firmware's own Home Assistant discovery messages declare (read from the 1.0.4 image): ``work_on`` and ``drying_running`` are "ON"/"OFF", ``mode`` is one of MODES, ``target_temp`` is 0-60 °C. The device is bound to one printer and reports that printer's serial number as ``printer_sn``, which is how it is matched to a Bambuddy printer. Bambuddy reuses the broker of the MQTT relay settings, like MQTT smart plugs. """ from __future__ import annotations import asyncio import json import logging import ssl import threading from dataclasses import dataclass from datetime import datetime, timezone from typing import Any import paho.mqtt.client as mqtt from paho.mqtt.enums import CallbackAPIVersion from backend.app.utils.paho_teardown import retire_paho_client logger = logging.getLogger(__name__) TOPIC_PREFIX = "panda_breath" MODES = ("auto mode", "power on", "filament drying") DRYING_MODES = ("pla", "petg", "custom") MAX_TARGET_TEMP_C = 60 @dataclass class PandaBreathDevice: """The last values one device reported.""" device_id: str online: bool | None = None chamber_temp: float | None = None target_temp: float | None = None work_on: bool | None = None mode: str | None = None filament_drying_mode: str | None = None drying_running: bool | None = None drying_remaining_min: float | None = None printer_sn: str | None = None last_seen: datetime | None = None def to_dict(self, broker_up: bool = True) -> dict[str, Any]: """The values the printer card shows (no printer serial number). Without a broker connection nothing can reach the device and its last values are stale, so it counts as offline then. """ return { "device_id": self.device_id, "online": self.online if broker_up else False, "chamber_temp": self.chamber_temp, "target_temp": self.target_temp, "work_on": self.work_on, "mode": self.mode, "filament_drying_mode": self.filament_drying_mode, "drying_running": self.drying_running, "drying_remaining_min": self.drying_remaining_min, } def _on_off(value: Any) -> bool | None: if isinstance(value, bool): return value if value is None: return None text = str(value).strip().upper() if text in ("ON", "TRUE", "1"): return True if text in ("OFF", "FALSE", "0"): return False return None def _number(value: Any) -> float | None: if isinstance(value, bool) or value is None: return None try: return float(value) except (TypeError, ValueError): return None def _text(value: Any) -> str | None: if value is None: return None text = str(value).strip() return text or None def _same_serial(a: str | None, b: str | None) -> bool: return bool(a) and bool(b) and a.strip().upper() == b.strip().upper() class PandaBreathService: """Follows Panda Breath devices on the shared broker and sends them commands.""" def __init__(self) -> None: self.client: mqtt.Client | None = None self.connected = False self.enabled = False self.devices: dict[str, PandaBreathDevice] = {} self._lock = threading.Lock() self._disconnection_event: threading.Event | None = None self._broker = "" self._port = 1883 self._username = "" self._password = "" self._use_tls = False # -- connection ------------------------------------------------------- async def configure(self, settings: dict) -> None: """Follow the relay's broker while both MQTT and Panda Breath are on.""" enabled = bool(settings.get("mqtt_enabled")) and bool(settings.get("panda_breath_enabled")) broker = settings.get("mqtt_broker") or "" if not enabled or not broker: self.enabled = False await self.disconnect() self._forget_devices() return port = int(settings.get("mqtt_port") or 1883) username = settings.get("mqtt_username") or "" password = settings.get("mqtt_password") or "" use_tls = bool(settings.get("mqtt_use_tls")) changed = (broker, port, username, password, use_tls) != ( self._broker, self._port, self._username, self._password, self._use_tls, ) self._broker, self._port, self._username, self._password, self._use_tls = ( broker, port, username, password, use_tls, ) self.enabled = True if changed and self.client: await self.disconnect() self._forget_devices() if not self.client: await self._connect() def _forget_devices(self) -> None: """Drop every device and refresh the cards that showed one.""" with self._lock: serials = {d.printer_sn for d in self.devices.values() if d.printer_sn} self.devices.clear() self._broadcast(serials) def _broadcast(self, serials: set[str]) -> None: if not serials: return from backend.app.services.printer_manager import printer_manager for serial in serials: printer_id = printer_manager.printer_id_for_serial(serial) if printer_id is not None: printer_manager.schedule_status_broadcast(printer_id) def _bound_serials(self) -> set[str]: with self._lock: return {d.printer_sn for d in self.devices.values() if d.printer_sn} async def _connect(self) -> None: try: client = mqtt.Client( callback_api_version=CallbackAPIVersion.VERSION2, client_id=f"bambuddy-pandabreath-{id(self)}", protocol=mqtt.MQTTv311, ) client.on_connect = self._on_connect client.on_disconnect = self._on_disconnect client.on_message = self._on_message if self._username: client.username_pw_set(self._username, self._password) if self._use_tls: client.tls_set(cert_reqs=ssl.CERT_NONE) client.tls_insecure_set(True) self.client = client try: await asyncio.wait_for( asyncio.to_thread(client.connect_async, self._broker, self._port, 60), timeout=3.0, ) except TimeoutError: logger.warning("Panda Breath: connection to %s:%s timed out", self._broker, self._port) client.loop_start() except Exception as e: logger.error("Panda Breath: MQTT connection failed: %s", e) self.connected = False def _on_connect(self, client, userdata, flags, reason_code, properties=None) -> None: rc = reason_code if isinstance(reason_code, int) else reason_code.value self.connected = rc == 0 if self.connected: client.subscribe(f"{TOPIC_PREFIX}/+/state", qos=1) client.subscribe(f"{TOPIC_PREFIX}/+/availability", qos=1) logger.info("Panda Breath: listening on %s:%s", self._broker, self._port) else: logger.warning("Panda Breath: broker refused the connection: %s", reason_code) def _on_disconnect(self, client, userdata, flags_or_rc, reason_code=None, properties=None) -> None: was_connected = self.connected self.connected = False if self._disconnection_event: self._disconnection_event.set() if was_connected: # The cards now show their devices offline. self._broadcast(self._bound_serials()) async def disconnect(self, timeout: float = 0) -> None: if not self.client: return try: self._disconnection_event = threading.Event() self.client.disconnect() await asyncio.to_thread(self._disconnection_event.wait, timeout=timeout) retire_paho_client(self.client, "panda-breath") except Exception as e: logger.debug("Panda Breath disconnect error (ignored): %s", e) finally: self.client = None self.connected = False # -- incoming --------------------------------------------------------- def _on_message(self, client, userdata, msg) -> None: try: payload = msg.payload.decode("utf-8", errors="replace") except Exception: return printer_ids = self.apply_message(msg.topic or "", payload) if printer_ids: from backend.app.services.printer_manager import printer_manager for printer_id in printer_ids: printer_manager.schedule_status_broadcast(printer_id) def apply_message(self, topic: str, payload: str) -> set[int]: """Take one message in; return the printers whose card changed.""" parts = topic.split("/") if len(parts) != 3 or parts[0] != TOPIC_PREFIX or not parts[1]: return set() device_id, kind = parts[1], parts[2] with self._lock: device = self.devices.get(device_id) or PandaBreathDevice(device_id=device_id) before = (device.to_dict(), device.printer_sn) if kind == "availability": device.online = payload.strip().lower() == "online" elif kind == "state": try: data = json.loads(payload) except json.JSONDecodeError: return set() if not isinstance(data, dict): return set() self._apply_state(device, data) device.online = True if device.online is None else device.online else: return set() device.last_seen = datetime.now(timezone.utc) self.devices[device_id] = device if (device.to_dict(), device.printer_sn) == before: return set() serials = {s for s in (before[1], device.printer_sn) if s} return {pid for pid in (self._printer_id_for_serial(s) for s in serials) if pid is not None} @staticmethod def _apply_state(device: PandaBreathDevice, data: dict) -> None: if "chamber_temp" in data: device.chamber_temp = _number(data["chamber_temp"]) if "target_temp" in data: device.target_temp = _number(data["target_temp"]) if "work_on" in data: device.work_on = _on_off(data["work_on"]) if "mode" in data: device.mode = _text(data["mode"]) if "filament_drying_mode" in data: device.filament_drying_mode = _text(data["filament_drying_mode"]) if "drying_running" in data: device.drying_running = _on_off(data["drying_running"]) if "drying_remaining_min" in data: device.drying_remaining_min = _number(data["drying_remaining_min"]) if "printer_sn" in data: device.printer_sn = _text(data["printer_sn"]) @staticmethod def _printer_id_for_serial(serial: str) -> int | None: from backend.app.services.printer_manager import printer_manager return printer_manager.printer_id_for_serial(serial) # -- lookups ---------------------------------------------------------- def device_for_serial(self, serial: str | None) -> PandaBreathDevice | None: """The device bound to the printer with this serial number.""" if not self.enabled or not serial: return None with self._lock: matches = [d for d in self.devices.values() if _same_serial(d.printer_sn, serial)] if not matches: return None # Two devices claiming one printer: the one heard from last. return max(matches, key=lambda d: d.last_seen or datetime.min.replace(tzinfo=timezone.utc)) def state_for_serial(self, serial: str | None) -> dict[str, Any] | None: """What the card of the printer with this serial shows, or None.""" device = self.device_for_serial(serial) return device.to_dict(self.connected) if device else None def state_for_printer(self, printer_id: int | None) -> dict[str, Any] | None: """The same for a connected printer, known by id (WebSocket status).""" if printer_id is None or not self.enabled: return None from backend.app.services.printer_manager import printer_manager info = printer_manager.get_printer(printer_id) return self.state_for_serial(info.serial_number if info else None) def get_status(self, printers: dict[str, tuple[int, str]]) -> dict[str, Any]: """For Settings: the connection and every device heard from. ``printers`` maps an upper-case serial number to (id, name) for the printers the caller may see; a device bound to any other printer is listed without naming it. """ with self._lock: devices = list(self.devices.values()) rows = [] for device in sorted(devices, key=lambda d: d.device_id): printer = printers.get((device.printer_sn or "").strip().upper()) rows.append( { **device.to_dict(self.connected), "bound": bool(device.printer_sn), "printer_id": printer[0] if printer else None, "printer_name": printer[1] if printer else None, } ) return {"enabled": self.enabled, "connected": self.connected, "devices": rows} # -- outgoing --------------------------------------------------------- def send_command(self, device_id: str, key: str, value: Any) -> bool: """Publish one value change; False when the broker is not reachable.""" if not self.client or not self.connected: return False topic = f"{TOPIC_PREFIX}/{device_id}/command" info = self.client.publish(topic, json.dumps({key: value}), qos=1, retain=False) return info.rc == mqtt.MQTT_ERR_SUCCESS panda_breath_service = PandaBreathService()