temporarily revert to previous version for seeds data collection

app.py

@@ -2,16 +2,27 @@ import gradio as gr
 import paho.mqtt.client as mqtt
 import json
 import time
+import threading
 import os
-import requests
-import traceback
+import base64
 from PIL import Image
 import io
-import threading
+import numpy as np
+import logging
+import sys
+import random
+import cv2
+from PIL import ImageDraw
+import requests
 
-print("Starting MQTT Print Control...")
 
-# Environment variables
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout), logging.FileHandler("app.log")],
+)
+logger = logging.getLogger("bambu-analysis")
+
 BAMBU_HOST = os.environ.get("BAMBU_HOST", "default_host")
 BAMBU_PORT = int(os.environ.get("BAMBU_PORT", 1883))
 BAMBU_USERNAME = os.environ.get("BAMBU_USERNAME", "default_user")
@@ -23,120 +34,615 @@ RPI_PORT = int(os.environ.get("RPI_PORT", 1883))
 RPI_USERNAME = os.environ.get("RPI_USERNAME", "default_user")
 RPI_PASSWORD = os.environ.get("RPI_PASSWORD", "default_pass")
 
-latest_data = {}
+logger.info(
+    f"BAMBU MQTT Configuration: HOST={BAMBU_HOST}, PORT={BAMBU_PORT}, USERNAME={BAMBU_USERNAME}, PWD={'*'*len(BAMBU_PASSWORD)}"
+)
+logger.info(
+    f"RPI MQTT Configuration: HOST={RPI_HOST}, PORT={RPI_PORT}, USERNAME={RPI_USERNAME}, PWD={'*'*len(RPI_PASSWORD)}"
+)
+
+latest_data = {
+    "bed_temperature": "N/A",
+    "nozzle_temperature": "N/A",
+    "status": "N/A",
+    "update_time": "Waiting for data...",
+    "image_url": "N/A",
+    "progress": 0,
+    "message": "",
+}
+
+bambu_client = None
+rpi_client = None
+response_topic = None  # Will be set dynamically
+
+# add a global variable to track if the application just started
+is_first_load = True
 
 
-# Centralized MQTT client setup
-def setup_mqtt_client(host, port, username, password, on_message):
-    client = mqtt.Client()
-    client.username_pw_set(username, password)
-    client.on_message = on_message
-    client.connect(host, port)
-    client.loop_start()
-    return client
+def create_client(client_type):
+    global bambu_client, rpi_client
+    if client_type == "bambu":
+        bambu_client = mqtt.Client()
+        bambu_client.username_pw_set(BAMBU_USERNAME, BAMBU_PASSWORD)
+        bambu_client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
+        bambu_client.on_connect = on_connect
+        bambu_client.on_message = bambu_on_message
+        bambu_client.connect(BAMBU_HOST, BAMBU_PORT)
+        bambu_client.loop_start()
+    elif client_type == "rpi":
+        rpi_client = mqtt.Client()
+        rpi_client.username_pw_set(RPI_USERNAME, RPI_PASSWORD)
+        rpi_client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
+        rpi_client.on_connect = on_connect
+        rpi_client.on_message = rpi_on_message
+        rpi_client.connect(RPI_HOST, RPI_PORT)
+        rpi_client.loop_start()
+
+
+def on_connect(client, userdata, flags, rc):
+    logger.info(f"Connected with result code {rc}")
 
 
-# Single callback responsibility
 def bambu_on_message(client, userdata, message):
     global latest_data
-    latest_data.update(json.loads(message.payload))
-    latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+    logger.info("Received message")
+    try:
+        data = json.loads(message.payload)
+        latest_data["bed_temperature"] = data.get("bed_temperature", "N/A")
+        latest_data["nozzle_temperature"] = data.get("nozzle_temperature", "N/A")
+        latest_data["status"] = data.get("status", "N/A")
+        latest_data["update_time"] = time.strftime(
+            "%Y-%m-%d %H:%M:%S", time.localtime()
+        )
+        latest_data["image_url"] = data.get("image_url", "N/A")
+    except Exception as e:
+        logger.error(f"Error parsing MQTT message: {e}")
 
 
-def rpi_on_message(client, userdata, message):
+def rpi_on_message(client, userdata, msg):
     global latest_data
-    latest_data.update(json.loads(message.payload))
-    latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-
 
-# Centralized error handling
-def main_logic():
-    global bambu_client, rpi_client
     try:
-        bambu_client = setup_mqtt_client(
-            BAMBU_HOST, BAMBU_PORT, BAMBU_USERNAME, BAMBU_PASSWORD, bambu_on_message
-        )
-        rpi_client = setup_mqtt_client(
-            RPI_HOST, RPI_PORT, RPI_USERNAME, RPI_PASSWORD, rpi_on_message
+        payload = msg.payload.decode("utf-8")
+        logger.info(f"Received message from RPI: {payload}")
+
+        data = json.loads(payload)
+        status = data.get("status", "Unknown")
+
+        latest_data["status"] = status
+        latest_data["update_time"] = data.get(
+            "update_time", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
         )
-        bambu_client.subscribe(f"bambu_a1_mini/response/{DEFAULT_SERIAL}")
-        rpi_client.subscribe(f"bambu_a1_mini/response/{DEFAULT_SERIAL}")
-    except Exception:
-        print("MQTT setup failed:")
-        traceback.print_exc()
+
+        if "nozzle_temperature" in data:
+            latest_data["nozzle_temperature"] = data["nozzle_temperature"]
+
+        if "bed_temperature" in data:
+            latest_data["bed_temperature"] = data["bed_temperature"]
+
+        if "error" in data:
+            logger.error(f"Error from RPI: {data['error']}")
+
+        if status == "Ready":
+            latest_data["progress"] = 0
+            latest_data["message"] = "Printer ready"
+        elif status == "Processing":
+            latest_data["progress"] = 25
+            latest_data["message"] = "Processing G-code..."
+
+    except Exception as e:
+        logger.error(f"Error processing message from RPI: {e}")
+
+        try:
+            result = json.loads(payload)
+
+            if "status" in result:
+                status = result["status"]
+                latest_data["status"] = status
+
+            if (
+                "command" in result
+                and result["command"] == "capture_image"
+                and result.get("auto_triggered", False)
+            ):
+                logger.info("receive capture command")
+                threading.Thread(
+                    target=handle_auto_capture, args=(result,), daemon=True
+                ).start()
+
+        except json.JSONDecodeError:
+            logger.error(f"Invalid JSON in message: {payload}")
+
+
+def get_data(serial=DEFAULT_SERIAL):
+    global bambu_client, response_topic
+
+    if bambu_client is None:
+        create_client("bambu")
+
+    request_topic = f"bambu_a1_mini/request/{serial}"
+    response_topic = f"bambu_a1_mini/response/{serial}"
+
+    logger.info(f"Subscribing to {response_topic}")
+    bambu_client.subscribe(response_topic)
+
+    logger.info(f"Publishing request to {request_topic}")
+    bambu_client.publish(request_topic, json.dumps("HI"))
+
+    global latest_data
+    latest_data["bed_temperature"] = "N/A"
+    timeout = 10
+    while latest_data["bed_temperature"] == "N/A" and timeout > 0:
+        time.sleep(1)
+        timeout -= 1
+
+    return (
+        latest_data["status"],
+        latest_data["bed_temperature"],
+        latest_data["nozzle_temperature"],
+        latest_data["update_time"],
+    )
 
 
-# Sending print parameters functionality
 def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
+    global rpi_client
+
+    serial = DEFAULT_SERIAL
+
+    logger.info(
+        f"Sending parameters to RPi for G-code generation: nozzle={nozzle_temp}, bed={bed_temp}, "
+        f"speed={print_speed}, fan={fan_speed}"
+    )
+
     try:
         params = {
             "nozzle_temp": nozzle_temp,
             "bed_temp": bed_temp,
             "print_speed": print_speed,
             "fan_speed": fan_speed,
-            "command": "generate_gcode",
         }
-        topic = f"bambu_a1_mini/request/{DEFAULT_SERIAL}"
-        rpi_client.publish(topic, json.dumps(params))
-        return "Parameters sent successfully."
-    except Exception:
-        print("Failed to send parameters:")
-        traceback.print_exc()
-        return "Failed to send parameters."
 
+        request_topic = f"bambu_a1_mini/request/{serial}"
+
+        if rpi_client:
+            rpi_client.publish(
+                request_topic,
+                json.dumps({"command": "generate_gcode", "parameters": params}),
+            )
+            logger.info("Parameters sent successfully to RPi for G-code generation")
+
+            global latest_data
+            latest_data["status"] = "Sent"
+            latest_data["update_time"] = time.strftime(
+                "%Y-%m-%d %H:%M:%S", time.localtime()
+            )
+
+            return "Parameters sent successfully to RPi. Status: Sent"
+        else:
+            logger.warning("MQTT not connected, parameters not sent")
+            return "MQTT not connected, parameters not sent"
+    except Exception as e:
+        logger.error(f"Error sending parameters: {e}")
+        return f"Error sending parameters: {e}"
+
+    latest_data["status"] = "Sending"
+    latest_data["progress"] = 10
+    latest_data["message"] = "Sending parameters to printer..."
 
-# Simple Gradio interface
-def get_status():
-    return (
-        latest_data.get("status", "N/A"),
-        latest_data.get("bed_temperature", "N/A"),
-        latest_data.get("nozzle_temperature", "N/A"),
-        latest_data.get("update_time", "Waiting for data..."),
-    )
+
+def get_image_base64(image):
+    if image is None:
+        logger.warning("No image to encode")
+        return None
+
+    try:
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        logger.info(f"Image encoded to base64 (length: {len(img_str)})")
+        return img_str
+    except Exception as e:
+        logger.error(f"Error encoding image: {e}")
+        return None
 
 
-# Image capture functionality
-def capture_image():
+def handle_auto_capture(message):
     try:
-        img_url = latest_data.get("image_url", None)
-        if img_url and img_url != "N/A":
-            response = requests.get(img_url, timeout=10)
+        logger.info(f"receive capture command: {message}")
+
+        print_job = message.get("print_job", "unknown_job")
+        timestamp = message.get("timestamp", time.strftime("%Y-%m-%d %H:%M:%S"))
+
+        latest_data["auto_capture_requested"] = True
+        latest_data["last_capture_job"] = print_job
+        latest_data["last_capture_time"] = timestamp
+
+        return capture_image()
+    except Exception as e:
+        logger.error(f"error: {e}")
+        return None, f"capture failed: {str(e)}"
+
+
+def capture_image(url=None):
+    global rpi_client, latest_data
+
+    if rpi_client is None:
+        create_client("rpi")
+
+    serial = DEFAULT_SERIAL
+    request_topic = f"bambu_a1_mini/request/{serial}"
+    response_topic = f"bambu_a1_mini/response/{serial}"
+
+    logger.info(f"Subscribing to {response_topic}")
+    rpi_client.subscribe(response_topic)
+
+    rpi_client.publish(
+        request_topic,
+        json.dumps(
+            {
+                "command": "capture_image",
+            }
+        ),
+    )
+
+    latest_data["image_url"] = "N/A"
+    timeout = 45
+    while latest_data["image_url"] == "N/A" and timeout > 0:
+        # print("timeout", timeout)
+        time.sleep(1)
+        timeout -= 1
+
+    url = latest_data["image_url"]
+
+    if url != "N/A":
+        try:
+            logger.info(f"Capturing image from URL: {url}")
+            response = requests.get(url, timeout=10)
             if response.status_code == 200:
                 return Image.open(io.BytesIO(response.content))
-        return None
-    except Exception:
-        print("Image capture failed:")
-        traceback.print_exc()
-        return None
+            else:
+                logger.error(f"Failed to get image from URL: {response.status_code}")
+        except Exception as e:
+            logger.error(f"Error capturing image from URL: {e}")
+    else:
+        raise Exception("url is 'N/A'")
+
+
+def update_print_status():
+    global latest_data
+    return (
+        latest_data["status"],
+        latest_data["nozzle_temperature"],
+        latest_data["bed_temperature"],
+        latest_data["update_time"],
+        latest_data.get("progress", 0),
+        latest_data.get("message", ""),
+    )
+
+
+def health_check():
+    status = {
+        "app": "running",
+        "time": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "bambu_mqtt_connected": bambu_client is not None,
+        "rpi_mqtt_connected": rpi_client is not None,
+        "latest_update": latest_data["update_time"],
+    }
+    logger.info(f"Health check: {status}")
+    return status
+
+
+demo = gr.Blocks(title="Bambu A1 Mini Print Control")
+
+with demo:
+    gr.Markdown("# Bambu A1 Mini Print Control")
+
+    with gr.Row():
+        refresh_btn = gr.Button("Refresh Status")
 
+    with gr.Row():
+        current_status = gr.Textbox(
+            label="Printer Status", value="N/A", interactive=False
+        )
+        current_bed_temp = gr.Textbox(
+            label="Current Bed Temperature", value="N/A", interactive=False
+        )
+        current_nozzle_temp = gr.Textbox(
+            label="Current Nozzle Temperature", value="N/A", interactive=False
+        )
+        last_update = gr.Textbox(label="Last Update", value="N/A", interactive=False)
+
+    with gr.Row():
+        # Left column for image and capture button
+        with gr.Column(scale=2):
+            captured_image = gr.Image(label="Current Print Image", type="pil")
+            capture_btn = gr.Button("Capture Image")
 
-with gr.Blocks(title="Simplified Printer Control") as demo:
-    status = gr.Textbox(label="Status")
-    bed_temp = gr.Textbox(label="Bed Temperature")
-    nozzle_temp = gr.Textbox(label="Nozzle Temperature")
-    update_time = gr.Textbox(label="Last Update")
-    image_display = gr.Image(label="Captured Image", type="pil")
+        # Right column for queue status and livestream
+        with gr.Column(scale=1):
+            gr.Markdown("### YouTube Livestream")
+            iframe_html = """
+            <div style="position: relative; width: 100%; padding-top: 56.25%;">
+                <iframe 
+                    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" 
+                    src="https://www.youtube.com/embed/ZzYOO6y6cJU" 
+                    title="Bambu A1mini Livestream" 
+                    frameborder="0" 
+                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
+                    referrerpolicy="strict-origin-when-cross-origin" 
+                    allowfullscreen>
+                </iframe>
+            </div>
+            """
+            gr.HTML(iframe_html)
 
-    nozzle_input = gr.Slider(
-        label="Nozzle Temperature", minimum=180, maximum=250, value=200
+    with gr.Row():
+        with gr.Column():
+            nozzle_temp = gr.Slider(
+                minimum=180,
+                maximum=250,
+                step=1,
+                value=200,
+                label="Nozzle Temperature (°C)",
+            )
+            bed_temp = gr.Slider(
+                minimum=40, maximum=100, step=1, value=60, label="Bed Temperature (°C)"
+            )
+            print_speed = gr.Slider(
+                minimum=20, maximum=150, step=1, value=60, label="Print Speed (mm/s)"
+            )
+            fan_speed = gr.Slider(
+                minimum=0, maximum=100, step=1, value=100, label="Fan Speed (%)"
+            )
+
+            send_params_btn = gr.Button("Send Print Parameters")
+
+    refresh_btn.click(
+        fn=get_data,
+        outputs=[current_status, current_bed_temp, current_nozzle_temp, last_update],
     )
-    bed_input = gr.Slider(label="Bed Temperature", minimum=40, maximum=100, value=60)
-    speed_input = gr.Slider(label="Print Speed", minimum=20, maximum=150, value=60)
-    fan_input = gr.Slider(label="Fan Speed", minimum=0, maximum=100, value=100)
 
-    refresh = gr.Button("Refresh")
-    refresh.click(fn=get_status, outputs=[status, bed_temp, nozzle_temp, update_time])
+    capture_btn.click(
+        fn=lambda: gr.update(interactive=False), outputs=capture_btn
+    ).then(fn=capture_image, outputs=[captured_image]).then(
+        fn=lambda: gr.update(interactive=True), outputs=capture_btn
+    )
 
-    capture_btn = gr.Button("Capture Image")
-    capture_btn.click(fn=capture_image, outputs=image_display)
+    def api_send_print_parameters(
+        nozzle_temp=200, bed_temp=60, print_speed=60, fan_speed=100
+    ):
+        """API endpoint to send print parameters to the Bambu printer via RPI MQTT"""
+        global is_first_load
+    
+        # if the application just started, skip the actual operation
+        if is_first_load:
+            logger.info("First load detected, skipping automatic parameter sending")
+            is_first_load = False
+            return "Ready to send parameters. Click 'Submit' to send."
+        
+        # the original function, only execute when the user explicitly requests it
+        return send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed)
 
-    send_params_btn = gr.Button("Send Parameters")
     send_params_btn.click(
-        fn=send_print_parameters,
-        inputs=[nozzle_input, bed_input, speed_input, fan_input],
-        outputs=status,
+        fn=api_send_print_parameters,
+        inputs=[nozzle_temp, bed_temp, print_speed, fan_speed],
+        outputs=[current_status],
+    )
+
+    def api_get_data():
+        logger.info("API call: get_data")
+        return get_data()
+
+    def api_capture_frame(url=None):
+        logger.info(f"API call: capture_frame with URL: {url}")
+
+        try:
+            img = capture_image(url)
+            if img:
+                if img.mode == "RGBA":
+                    img = img.convert("RGB")
+
+                buffered = io.BytesIO()
+                img.save(buffered, format="JPEG")
+                img_str = base64.b64encode(buffered.getvalue()).decode()
+
+                return {"success": True, "image": img_str}
+            else:
+                return {"success": False, "error": "Failed to capture image"}
+        except Exception as e:
+            logger.error(f"Error in capture_frame: {e}")
+            return {"success": False, "error": str(e)}
+
+    def api_lambda(
+        img_data=None,
+        param_1=200,
+        param_2=60,
+        param_3=60,
+        param_4=100,
+    ):
+        logger.info(
+            f"API call: lambda with params: {param_1}, {param_2}, {param_3}, {param_4}"
+        )
+        try:
+            img = None
+
+            if (
+                img_data
+                and isinstance(img_data, str)
+                and (img_data.startswith("http://") or img_data.startswith("https://"))
+            ):
+                logger.info(f"Lambda received image URL: {img_data}")
+                img = capture_image(img_data)
+
+            elif img_data and isinstance(img_data, str):
+                try:
+                    logger.info("Lambda received base64 image data")
+                    img_bytes = base64.b64decode(img_data)
+                    img = Image.open(io.BytesIO(img_bytes))
+                except Exception as e:
+                    logger.error(f"Failed to decode base64 image: {e}")
+
+            if img:
+                img_array = np.array(img)
+
+                quality_level = "low"
+                if 190 <= param_1 <= 210 and param_3 <= 50 and param_4 >= 80:
+                    quality_level = "high"
+                elif 185 <= param_1 <= 215 and param_3 <= 70 and param_4 >= 60:
+                    quality_level = "medium"
+
+                if quality_level == "high":
+                    missing_rate = 0.02
+                    excess_rate = 0.01
+                    stringing_rate = 0.01
+                elif quality_level == "medium":
+                    missing_rate = 0.05
+                    excess_rate = 0.03
+                    stringing_rate = 0.02
+                else:  # low
+                    missing_rate = 0.10
+                    excess_rate = 0.07
+                    stringing_rate = 0.05
+
+                uniformity_score = 1.0 - (missing_rate + excess_rate + stringing_rate)
+
+                print_quality_score = 1.0 - (
+                    missing_rate * 2.0 + excess_rate * 1.5 + stringing_rate * 1.0
+                )
+                print_quality_score = max(0, min(1, print_quality_score))
+
+                print_speed_score = param_3 / 150.0
+                print_speed_score = max(0, min(1, print_speed_score))
+
+                material_efficiency_score = 1.0 - excess_rate * 3.0
+                material_efficiency_score = max(0, min(1, material_efficiency_score))
+
+                total_performance_score = (
+                    0.5 * print_quality_score
+                    + 0.3 * print_speed_score
+                    + 0.2 * material_efficiency_score
+                )
+
+                img_draw = img.copy()
+                draw = ImageDraw.Draw(img_draw)
+                draw.text(
+                    (10, 10), f"Quality: {quality_level.upper()}", fill=(255, 0, 0)
+                )
+                draw.text((10, 30), f"Missing: {missing_rate:.2f}", fill=(255, 0, 0))
+                draw.text((10, 50), f"Excess: {excess_rate:.2f}", fill=(255, 0, 0))
+                draw.text(
+                    (10, 70), f"Stringing: {stringing_rate:.2f}", fill=(255, 0, 0)
+                )
+
+                result = {
+                    "success": True,
+                    "missing_rate": missing_rate,
+                    "excess_rate": excess_rate,
+                    "stringing_rate": stringing_rate,
+                    "uniformity_score": uniformity_score,
+                    "print_quality_score": print_quality_score,
+                    "print_speed_score": print_speed_score,
+                    "material_efficiency_score": material_efficiency_score,
+                    "total_performance_score": total_performance_score,
+                }
+
+                if img_draw.mode == "RGBA":
+                    img_draw = img_draw.convert("RGB")
+
+                buffered = io.BytesIO()
+                img_draw.save(buffered, format="JPEG")
+                img_str = base64.b64encode(buffered.getvalue()).decode()
+                result["image"] = img_str
+
+                return result
+            else:
+                return {"success": False, "error": "Failed to get image"}
+        except Exception as e:
+            logger.error(f"Error in lambda: {e}")
+            return {"error": str(e)}
+
+
+    api_json_output = gr.JSON()
+    api_text_output = gr.Textbox()
+
+    capture_frame_api = demo.load(
+        fn=api_capture_frame,
+        inputs=[gr.Text(label="Camera URL (Optional)")],
+        outputs=[gr.Image(label="Captured Frame"), gr.JSON()],
+        api_name="capture_frame"
+    )
+
+    lambda_api = demo.load(
+        fn=api_lambda,
+        inputs=[
+            gr.Image(label="Image Data"),
+            gr.Number(label="Nozzle Temperature", value=200),
+            gr.Number(label="Bed Temperature", value=60),
+            gr.Number(label="Print Speed", value=60),
+            gr.Number(label="Fan Speed", value=100),
+        ],
+        outputs=[gr.Image(label="Visualization"), gr.JSON()],
+        api_name="lambda"
+    )
+
+    get_data_api = demo.load(
+        fn=api_get_data,
+        inputs=[],
+        outputs=gr.JSON(),
+        api_name="get_data"
+    )
+
+    send_params_api = demo.load(
+        fn=api_send_print_parameters,
+        inputs=[
+            gr.Number(label="Nozzle Temperature", value=200),
+            gr.Number(label="Bed Temperature", value=60),
+            gr.Number(label="Print Speed", value=60),
+            gr.Number(label="Fan Speed", value=100),
+        ],
+        outputs=api_text_output,
+        api_name="send_print_parameters"
+    )
+
+    get_status_api = demo.load(
+        fn=update_print_status,
+        inputs=[],
+        outputs=[
+            gr.Textbox(label="Status"),
+            gr.Textbox(label="Nozzle Temperature"),
+            gr.Textbox(label="Bed Temperature"),
+            gr.Textbox(label="Update Time"),
+            gr.Number(label="Progress"),
+            gr.Textbox(label="Message"),
+        ],
+        api_name="get_status"
+    )
+
+    health_check_api = demo.load(
+        fn=health_check,
+        inputs=[],
+        outputs=gr.JSON(),
+        api_name="health_check"
     )
 
-print("App initializing...")
-threading.Thread(target=main_logic, daemon=True).start()
-demo.launch()
+if __name__ == "__main__":
+    logger.info("Starting Bambu A1 Mini Print Control application")
+
+    try:
+        logger.info("Initializing Bambu MQTT client")
+        create_client("bambu")
+    except Exception as e:
+        logger.error(f"Failed to initialize Bambu MQTT: {e}")
+
+    try:
+        logger.info("Initializing RPI MQTT client")
+        create_client("rpi")
+    except Exception as e:
+        logger.error(f"Failed to initialize RPI MQTT: {e}")
+
+    demo.queue().launch(
+        show_error=True, share=False, server_name="0.0.0.0", server_port=7860
+    )