update

app.py

@@ -1,37 +1,33 @@
 import gradio as gr
-import numpy as np
-import cv2
 import paho.mqtt.client as mqtt
 import json
 import time
 import threading
 import os
-from io import BytesIO
-import zipfile
-import logging
-from dotenv import load_dotenv
-from mo_optimizer import MOPrintOptimizer
-from core.analysis import DefectDetector, ImageProcessor
-from datetime import datetime
-import requests
+import base64
 from PIL import Image
+import io
+import numpy as np
+import logging
+import sys
 
-# Load environment variables
-load_dotenv()
-
-# MQTT Configuration - 直接硬编码配置
-HOST = "mqtt.bambulab.com"
-PORT = 8883
-USERNAME = "bblp"
-PASSWORD = "bblp"
-PRINTER_SERIAL = "0309CA471800852"
-
-# Setup logging
+# 设置详细的日志记录
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('app.log')
+    ]
 )
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("bambu-analysis")
+
+# Environment Variables - 尝试从环境变量获取，如果没有则使用默认值
+HOST = os.environ.get("host", "mqtt.bambulab.com")
+PORT = int(os.environ.get("port", "8883"))
+USERNAME = os.environ.get("username", "bblp")
+PASSWORD = os.environ.get("password", "bblp")
+DEFAULT_SERIAL = "0309CA471800852"
 
 # Global variables
 client = None
@@ -42,111 +38,117 @@ latest_data = {
     "update_time": "Waiting for data..."
 }
 
-# Initialize analysis components
-optimizer = MOPrintOptimizer()
-detector = DefectDetector()
-
-# MQTT Topics structure
-WORKFLOW_STATUS = {
-    'print_started': False,
-    'print_completed': False,
-    'image_captured': False,
-    'analysis_completed': False,
-    'current_square_id': None,
-    'start_time': None,
-    'completion_time': None
-}
-
-def update_workflow_status(status_type: str, value: bool = True):
-    """Update workflow status
-    
-    Args:
-        status_type: Type of status to update
-        value: New status value
-    """
-    WORKFLOW_STATUS[status_type] = value
-    if status_type == 'print_started':
-        WORKFLOW_STATUS['start_time'] = time.strftime('%Y-%m-%d %H:%M:%S')
-    elif status_type == 'analysis_completed':
-        WORKFLOW_STATUS['completion_time'] = time.strftime('%Y-%m-%d %H:%M:%S')
-
-# Message formats
-def create_print_command(params):
-    return {
-        'type': 'print',
-        'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
-        'params': {
-            'nozzle_temp': params['nozzle_temp'],
-            'print_speed': params['print_speed'],
-            # ... other params
-        }
-    }
-
-def create_capture_command(square_id):
-    return {
-        'type': 'capture',
-        'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
-        'square_id': square_id
-    }
-
-def create_3mf_package(gcode_content: str, gcode_filename: str = "Metadata/plate_1.gcode") -> BytesIO:
-    """Create a 3MF package from G-code content"""
-    zip_buffer = BytesIO()
-    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
-        zipf.writestr(gcode_filename, gcode_content)
-    zip_buffer.seek(0)
-    return zip_buffer
-
 def create_client(host, port, username, password):
+    """创建并配置MQTT客户端"""
     global client
-    client = mqtt.Client()
-    client.username_pw_set(username, password)
-    client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
-    client.on_connect = on_connect
-    client.on_message = on_message
-    client.connect(host, port)
-    client.loop_start()
+    try:
+        logger.info(f"Creating MQTT client for {host}:{port}")
+        client = mqtt.Client()
+        client.username_pw_set(username, password)
+        client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
+        client.on_connect = on_connect
+        client.on_message = on_message
+        client.on_disconnect = on_disconnect
+        
+        logger.info("Connecting to MQTT broker...")
+        client.connect(host, port)
+        client.loop_start()
+        return True
+    except Exception as e:
+        logger.error(f"Failed to create MQTT client: {e}")
+        return False
 
 def on_connect(client, userdata, flags, rc):
-    print(f"Connected with result code {rc}")
+    """MQTT连接回调"""
+    if rc == 0:
+        logger.info("Successfully connected to MQTT broker")
+        serial = DEFAULT_SERIAL
+        response_topic = f"bambu_a1_mini/response/{serial}"
+        request_topic = f"bambu_a1_mini/request/{serial}"
+        
+        try:
+            client.subscribe(response_topic)
+            logger.info(f"Subscribed to {response_topic}")
+            
+            # 发送初始请求
+            client.publish(request_topic, json.dumps("HI"))
+            logger.info(f"Sent initial request to {request_topic}")
+            
+            # 更新状态
+            global latest_data
+            latest_data["status"] = "Connected"
+            latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S")
+        except Exception as e:
+            logger.error(f"Error in on_connect callback: {e}")
+    else:
+        logger.error(f"Failed to connect to MQTT broker with code: {rc}")
 
 def on_message(client, userdata, message):
-    global latest_data
-    print("Received message")
+    """MQTT消息回调"""
     try:
+        logger.info(f"Received message on topic: {message.topic}")
         data = json.loads(message.payload)
+        logger.debug(f"Message content: {data}")
+        
+        global latest_data
         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["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S")
     except Exception as e:
-        print(f"Error parsing MQTT message: {e}")
+        logger.error(f"Error parsing MQTT message: {e}")
 
-def get_data():
-    """Request data from the MQTT broker."""
-    global client
-    if client is None:
-        create_client(HOST, PORT, USERNAME, PASSWORD)
-
-    serial = "0309CA471800852"
-    request_topic = f"bambu_a1_mini/request/{serial}"
-    response_topic = f"bambu_a1_mini/response/{serial}"
-    
-    print(f"Subscribing to {response_topic}")
-    client.subscribe(response_topic)
+def on_disconnect(client, userdata, rc):
+    """MQTT断开连接回调"""
+    logger.warning(f"Disconnected from MQTT broker with code: {rc}")
     
-    # Send a request to get data
-    client.publish(request_topic, json.dumps("HI"))
+    global latest_data
+    latest_data["status"] = "Disconnected"
+    latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S")
     
-    return (
-        latest_data["status"],
-        latest_data["bed_temperature"],
-        latest_data["nozzle_temperature"],
-        latest_data["update_time"]
-    )
+    if rc != 0:
+        logger.warning("Unexpected disconnection. Attempting to reconnect...")
+        try:
+            create_client(HOST, PORT, USERNAME, PASSWORD)
+        except Exception as e:
+            logger.error(f"Failed to reconnect: {e}")
+
+def get_data(serial=DEFAULT_SERIAL):
+    """获取打印机状态数据"""
+    logger.info("Requesting printer data")
+    try:
+        global client
+        if client is None or not client.is_connected():
+            logger.warning("MQTT client not connected. Attempting to connect...")
+            create_client(HOST, PORT, USERNAME, PASSWORD)
 
-def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
-    """Send new print parameters to printer"""
+        request_topic = f"bambu_a1_mini/request/{serial}"
+        response_topic = f"bambu_a1_mini/response/{serial}"
+        
+        logger.info(f"Subscribing to {response_topic}")
+        if client and client.is_connected():
+            client.subscribe(response_topic)
+            
+            # 发送请求
+            logger.info(f"Sending data request to {request_topic}")
+            client.publish(request_topic, json.dumps("HI"))
+            
+            return (
+                latest_data["status"],
+                latest_data["bed_temperature"],
+                latest_data["nozzle_temperature"],
+                latest_data["update_time"]
+            )
+        else:
+            logger.error("MQTT client not available")
+            return ("Disconnected", "N/A", "N/A", "MQTT not connected")
+    except Exception as e:
+        logger.error(f"Error in get_data: {e}")
+        return (f"Error: {str(e)}", "N/A", "N/A", time.strftime("%Y-%m-%d %H:%M:%S"))
+
+def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed, serial=DEFAULT_SERIAL):
+    """发送打印参数到打印机"""
+    logger.info(f"Sending parameters to {serial}: nozzle={nozzle_temp}, bed={bed_temp}, speed={print_speed}, fan={fan_speed}")
     try:
         params = {
             'nozzle_temp': nozzle_temp,
@@ -155,173 +157,200 @@ def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
             'fan_speed': fan_speed
         }
         
-        serial = PRINTER_SERIAL
         request_topic = f"bambu_a1_mini/request/{serial}"
-        if client:
+        
+        if client and client.is_connected():
             client.publish(request_topic, json.dumps({
                 'command': 'set_parameters',
                 'parameters': params
             }))
+            logger.info("Parameters sent successfully")
             return "Parameters sent successfully"
-        return "MQTT not connected"
+        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}"
 
-# Gradio interface
-with gr.Blocks(title="Bambu A1 Mini Print Analysis") as demo:
-    gr.Markdown("# Bambu A1 Mini Print Quality Analysis")
+def get_image_base64(image):
+    """将图像转换为base64用于API传输"""
+    if image is None:
+        logger.warning("No image to encode")
+        return None
+    
+    try:
+        # 转换为PIL图像
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # 转换为base64
+        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
+
+def capture_image():
+    """捕获当前打印图像"""
+    logger.info("Capturing print image")
+    try:
+        # 这里应该是实际的相机捕获代码
+        # 目前返回一个占位图像
+        logger.warning("Using placeholder image (camera not implemented)")
+        placeholder = Image.new('RGB', (300, 300), color=(200, 200, 200))
+        return placeholder
+    except Exception as e:
+        logger.error(f"Error capturing image: {e}")
+        return None
+
+def health_check():
+    """健康检查端点"""
+    status = {
+        "app": "running",
+        "time": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "mqtt_connected": client is not None and client.is_connected() if client else False,
+        "latest_update": latest_data["update_time"]
+    }
+    logger.info(f"Health check: {status}")
+    return status
+
+# 初始化MQTT客户端
+try:
+    logger.info("Initializing MQTT client")
+    mqtt_connected = create_client(HOST, PORT, USERNAME, PASSWORD)
+    if not mqtt_connected:
+        logger.warning("Starting without MQTT connection")
+except Exception as e:
+    logger.error(f"Failed to initialize MQTT: {e}")
+    logger.warning("Starting without MQTT connection")
+
+# Gradio界面
+with gr.Blocks(title="Bambu A1 Mini Print Control") as demo:
+    gr.Markdown("# Bambu A1 Mini Print Control")
+    
+    with gr.Row():
+        serial = gr.Textbox(DEFAULT_SERIAL, label="Serial Number")
+        refresh_btn = gr.Button("Refresh Status")
     
     with gr.Row():
-        current_nozzle_temp = gr.Textbox(label="Current Nozzle Temperature", value="N/A", interactive=False)
-        current_bed_temp = gr.Textbox(label="Current Bed Temperature", value="N/A", interactive=False)
         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)
 
-    refresh_btn = gr.Button("Refresh Status")
-
     with gr.Row():
-        # show S3 image
-        s3_image = gr.Image(
-            label="Latest S3 Image",
-            type="filepath",  # use URL
-            interactive=False
-        )
-        captured_image = gr.Image(
-            label="Current Print Image",
-            type="numpy"
-        )
+        captured_image = gr.Image(label="Current Print Image", type="pil")
+        capture_btn = gr.Button("Capture Image")
 
     with gr.Row():
         with gr.Column():
-            # Print parameter inputs
+            # 打印参数输入
             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 (%)")
             
-            # Buttons
-            with gr.Row():
-                capture_btn = gr.Button("Capture Image")
-                analyze_btn = gr.Button("Analyze Print")
-                send_params_btn = gr.Button("Send Print Parameters")
+            send_params_btn = gr.Button("Send Print Parameters")
 
-        with gr.Column():
-            # Results visualization
-            result_image = gr.Image(label="Analysis Result")
-            
-            # Quality metrics
-            with gr.Row():
-                missing_rate = gr.Number(label="Missing Rate", value=0.0)
-                excess_rate = gr.Number(label="Excess Rate", value=0.0)
-            with gr.Row():
-                stringing_rate = gr.Number(label="Stringing Rate", value=0.0)
-                uniformity_score = gr.Number(label="Uniformity Score", value=0.0)
-            
-            # Overall scores
-            with gr.Row():
-                quality_output = gr.Number(label="Print Quality Score")
-                speed_output = gr.Number(label="Print Speed Score")
-                material_output = gr.Number(label="Material Efficiency Score")
-                total_output = gr.Number(label="Total Performance Score")
-
-    # Connect inputs to outputs
-    def capture_frame(img):
-        """Capture current image for analysis"""
-        if img is None:
+    # API端点
+    def api_get_status(serial=DEFAULT_SERIAL):
+        """API端点：获取状态"""
+        logger.info(f"API call: get_status for {serial}")
+        try:
+            return get_data(serial)
+        except Exception as e:
+            logger.error(f"Error in api_get_status: {e}")
+            return ("Error", "N/A", "N/A", str(e))
+    
+    def api_get_image():
+        """API端点：获取图像"""
+        logger.info("API call: get_image")
+        try:
+            img = capture_image()
+            return get_image_base64(img)
+        except Exception as e:
+            logger.error(f"Error in api_get_image: {e}")
             return None
-        # Convert URL image to numpy array if needed
-        if isinstance(img, str):
-            response = requests.get(img)
-            img = Image.open(BytesIO(response.content))
-            img = np.array(img)
-        return img
     
-    capture_btn.click(
-        fn=capture_frame,
-        inputs=[s3_image],
-        outputs=[captured_image]
+    def api_send_parameters(params):
+        """API端点：发送参数"""
+        logger.info(f"API call: send_parameters with {params}")
+        try:
+            serial = params.get('serial', DEFAULT_SERIAL)
+            return send_print_parameters(
+                params.get('nozzle_temp', 200),
+                params.get('bed_temp', 60),
+                params.get('print_speed', 60),
+                params.get('fan_speed', 100),
+                serial
+            )
+        except Exception as e:
+            logger.error(f"Error in api_send_parameters: {e}")
+            return f"Error: {str(e)}"
+    
+    def api_health_check():
+        """API端点：健康检查"""
+        logger.info("API call: health_check")
+        try:
+            return health_check()
+        except Exception as e:
+            logger.error(f"Error in api_health_check: {e}")
+            return {"status": "error", "error": str(e)}
+    
+    # 连接按钮
+    refresh_btn.click(
+        fn=get_data,
+        inputs=[serial],
+        outputs=[current_status, current_bed_temp, current_nozzle_temp, last_update],
+        api_name="refresh_status"
     )
     
-    analyze_btn.click(
-        fn=lambda img, *params: (
-            analyze_print(img, *params),
-            send_print_command(dict(
-                nozzle_temp=params[0],      # nozzle_temp slider
-                print_speed=params[1],      # print_speed slider
-                bed_temp=params[1],         # bed_temp slider
-                fan_speed=params[2],        # fan_speed slider
-            ))
-        ),
-        inputs=[
-            captured_image,
-            nozzle_temp, bed_temp, print_speed, fan_speed
-        ],
-        outputs=[
-            result_image,
-            missing_rate, excess_rate,
-            stringing_rate, uniformity_score,
-            quality_output, speed_output,
-            material_output, total_output,
-            current_status
-        ]
+    capture_btn.click(
+        fn=capture_image,
+        outputs=[captured_image],
+        api_name="capture_image"
     )
     
-    # connect refresh button
-    refresh_btn.click(fn=get_data, outputs=[current_status, current_bed_temp, current_nozzle_temp, last_update])
-
-    # Auto refresh
-    def auto_refresh():
-        while True:
-            time.sleep(5)
-            status, bed_temp, nozzle_temp, update_time = get_data()
-            current_status.value = status
-            current_bed_temp.value = bed_temp
-            current_nozzle_temp.value = nozzle_temp
-            last_update.value = update_time
-
-    threading.Thread(target=auto_refresh, daemon=True).start()
-
-    # 连接按钮
     send_params_btn.click(
         fn=send_print_parameters,
-        inputs=[nozzle_temp, bed_temp, print_speed, fan_speed],
-        outputs=[current_status]
+        inputs=[nozzle_temp, bed_temp, print_speed, fan_speed, serial],
+        outputs=[current_status],
+        api_name="send_parameters"
     )
-
-def analyze_print(image, nozzle_temp, bed_temp, print_speed, fan_speed):
-    """Analyze print quality and return evaluation results"""
-    if image is None:
-        return None, 0, 0, 0, 0, 0, 0, 0, 0
     
-    # Package current parameters
-    current_params = {
-        'nozzle_temp': float(nozzle_temp),
-        'bed_temp': float(bed_temp),
-        'print_speed': float(print_speed),
-        'fan_speed': float(fan_speed)
-    }
-    
-    # Analyze print quality
-    analysis_results = detector.analyze_print(image)
-    
-    # Get optimization results
-    results = optimizer.evaluate_objectives(image, current_params)
-    
-    # Calculate quality metrics
-    metrics = detector.calculate_quality_metrics(image)
-    
-    return (
-        analysis_results['binary_mask'],  # Visualization
-        float(metrics['missing_rate']),
-        float(metrics['excess_rate']),
-        float(metrics['stringing_rate']),
-        float(metrics['uniformity_score']),
-        float(analysis_results['quality_score']),
-        float(results['objectives']['speed']),
-        float(results['objectives']['material']),
-        float(results['objectives']['total'])
-    )
+    # 定义API端点
+    demo.queue()
+    gr.Interface(fn=api_get_status, inputs=[serial], outputs="json", title="Get Printer Status").launch(share=True)
+    gr.Interface(fn=api_get_image, inputs=None, outputs="json", title="Get Print Image").launch(share=True)
+    gr.Interface(fn=api_send_parameters, inputs="json", outputs="text", title="Send Print Parameters").launch(share=True)
+    gr.Interface(fn=api_health_check, inputs=None, outputs="json", title="Health Check").launch(share=True)
+
+# 自动刷新线程
+def auto_refresh():
+    """自动刷新状态的后台线程"""
+    logger.info("Starting auto-refresh thread")
+    while True:
+        try:
+            time.sleep(5)
+            logger.debug("Auto-refreshing printer status")
+            status, bed_temp, nozzle_temp, update_time = get_data(DEFAULT_SERIAL)
+            
+            # 更新UI
+            current_status.update(value=status)
+            current_bed_temp.update(value=bed_temp)
+            current_nozzle_temp.update(value=nozzle_temp)
+            last_update.update(value=update_time)
+        except Exception as e:
+            logger.error(f"Auto refresh error: {e}")
+            time.sleep(10)  # 出错后等待更长时间再重试
+
+threading.Thread(target=auto_refresh, daemon=True).start()
 
-# Launch the app
+# 启动应用
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("Starting Bambu A1 Mini Print Control application")
+    demo.launch(show_error=True)  # 启用详细错误报告