Merge branch 'dev' of https://github.com/dptech-corp/Uni-Lab-OS into dev

* 修复了部分的protocol因为XDL更新导致的问题

但是pumptransfer，add，dissolve，separate还没修，后续还需要写virtual固体加料器

* 补充了四个action

* 添加了固体加样器，丰富了json，修改了add protocol

* bump version to 0.9.9

* fix bugs from new actions

* protocol完整修复版本& bump version to 0.9.10

* 修补了一些单位处理，bump version to 0.9.11

* 优化了全protocol的运行时间，除了pumptransfer相关的还没

* 补充了剩下的几个protocol

---------

Co-authored-by: Junhan Chang <changjh@dp.tech>
Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>

.gitignore

@@ -1,4 +1,5 @@
 configs/
+temp/
 ## Python
 
 # Byte-compiled / optimized / DLL files

README.md

@@ -49,7 +49,7 @@ conda env update --file unilabos-[YOUR_OS].yml -n environment_name
 
 # Currently, you need to install the `unilabos_msgs` package
 # You can download the system-specific package from the Release page
-conda install ros-humble-unilabos-msgs-0.9.8-xxxxx.tar.bz2
+conda install ros-humble-unilabos-msgs-0.9.10-xxxxx.tar.bz2
 
 # Install PyLabRobot and other prerequisites
 git clone https://github.com/PyLabRobot/pylabrobot plr_repo

README_zh.md

@@ -49,7 +49,7 @@ conda env update --file unilabos-[YOUR_OS].yml -n 环境名
 
 # 现阶段，需要安装 `unilabos_msgs` 包
 # 可以前往 Release 页面下载系统对应的包进行安装
-conda install ros-humble-unilabos-msgs-0.9.8-xxxxx.tar.bz2
+conda install ros-humble-unilabos-msgs-0.9.11-xxxxx.tar.bz2
 
 # 安装PyLabRobot等前置
 git clone https://github.com/PyLabRobot/pylabrobot plr_repo

recipes/ros-humble-unilabos-msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.9.8
+  version: 0.9.11
 source:
   path: ../../unilabos_msgs
   folder: ros-humble-unilabos-msgs/src/work

recipes/unilabos/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: "0.9.8"
+  version: "0.9.11"
 
 source:
   path: ../..

setup.py

@@ -4,7 +4,7 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.9.8',
+    version='0.9.11',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],

test/experiments/comprehensive_protocol/checklist.md

@@ -43,6 +43,15 @@
     Hydrogenate                                                                 <Hydrogenate temp="45 °C" time="?" vessel="main_reactor"/>
 4. 参数对齐
 
+
+
+
+
+
+
+
+
+
 class PumpTransferProtocol(BaseModel):
     from_vessel: str
     to_vessel: str
@@ -51,9 +60,9 @@ class PumpTransferProtocol(BaseModel):
     time: float = 0
     viscous: bool = False
     rinsing_solvent: str = "air"        <Transfer from_vessel="main_reactor" to_vessel="rotavap"/>
-    rinsing_volume: float = 5000
-    rinsing_repeats: int = 2
-    solid: bool = False
+    rinsing_volume: float = 5000        <Transfer event="A" from_vessel="reactor" rate_spec="dropwise" to_vessel="main_reactor"/>
+    rinsing_repeats: int = 2            <Transfer from_vessel="separator" through="cartridge" to_vessel="rotavap"/>
+    solid: bool = False                 测完了三个都能跑✅
     flowrate: float = 500
     transfer_flowrate: float = 2500
 
@@ -66,25 +75,25 @@ class SeparateProtocol(BaseModel):
     waste_phase_to_vessel: str
     solvent: str
     solvent_volume: float               <Separate product_phase="bottom" purpose="wash" solvent="water" vessel="separator" volume="?"/>
-    through: str
-    repeats: int
-    stir_time: float
+    through: str                        <Separate product_phase="top" purpose="separate" vessel="separator"/>
+    repeats: int                        <Separate product_phase="bottom" purpose="extract" repeats="3" solvent="CH2Cl2" vessel="separator" volume="?"/>
+    stir_time: float                    <Separate product_phase="top" product_vessel="flask" purpose="separate" vessel="separator" waste_vessel="separator"/>
     stir_speed: float
-    settling_time: float
+    settling_time: float                测完了能跑✅
 
 
 class EvaporateProtocol(BaseModel):
     vessel: str
     pressure: float
     temp: float                         <Evaporate solvent="ethanol" vessel="rotavap"/>
-    time: float
+    time: float                         测完了能跑✅
     stir_speed: float
 
 
 class EvacuateAndRefillProtocol(BaseModel):
     vessel: str
     gas: str                            <EvacuateAndRefill gas="nitrogen" vessel="main_reactor"/>
-    repeats: int
+    repeats: int                        测完了能跑✅
 
 class AddProtocol(BaseModel):
     vessel: str
@@ -95,21 +104,27 @@ class AddProtocol(BaseModel):
     time: float
     stir: bool
     stir_speed: float                   <Add reagent="ethanol" vessel="main_reactor" volume="2.7 mL"/>
+    <Add event="A" mass="19.3 g" mol="0.28 mol" rate_spec="portionwise" reagent="sodium nitrite" time="1 h" vessel="main_reactor"/>
+    <Add mass="4.5 g" mol="16.2 mmol" reagent="(S)-2-phthalimido-6-hydroxyhexanoic acid" vessel="main_reactor"/>
+    <Add purpose="dilute" reagent="hydrochloric acid" vessel="main_reactor" volume="?"/>
+    <Add equiv="1.1" event="B" mol="25.2 mmol" rate_spec="dropwise" reagent="1-fluoro-2-nitrobenzene" time="20 min" 
+    vessel="main_reactor" volume="2.67 mL"/>
+    <Add ratio="?" reagent="tetrahydrofuran|tert-butanol" vessel="main_reactor" volume="?"/>
     viscous: bool
-    purpose: str
+    purpose: str                        测完了能跑✅
 
 class CentrifugeProtocol(BaseModel):
     vessel: str
     speed: float
-    time: float                         自创的
+    time: float                         没毛病
     temp: float
 
 class FilterProtocol(BaseModel):
     vessel: str
     filtrate_vessel: str
     stir: bool                          <Filter vessel="filter"/>
-    stir_speed: float
-    temp: float
+    stir_speed: float                   <Filter filtrate_vessel="rotavap" vessel="filter"/>
+    temp: float                         测完了能跑✅
     continue_heatchill: bool
     volume: float
 
@@ -118,7 +133,10 @@ class HeatChillProtocol(BaseModel):
     temp: float
     time: float                         <HeatChill pressure="1 mbar" temp_spec="room temperature" time="?" vessel="main_reactor"/>
                                         <HeatChill temp_spec="room temperature" time_spec="overnight" vessel="main_reactor"/>
-    stir: bool
+                                        <HeatChill temp="256 °C" time="?" vessel="main_reactor"/>
+                                        <HeatChill reflux_solvent="methanol" temp_spec="reflux" time="2 h" vessel="main_reactor"/>
+                                        <HeatChillToTemp temp_spec="room temperature" vessel="main_reactor"/>
+    stir: bool                          测完了能跑✅
     stir_speed: float
     purpose: str
 
@@ -133,7 +151,9 @@ class HeatChillStopProtocol(BaseModel):
 class StirProtocol(BaseModel):
     stir_time: float
     stir_speed: float               <Stir time="0.5 h" vessel="main_reactor"/>
-    settling_time: float
+                                    <Stir event="A" time="30 min" vessel="main_reactor"/>
+                                    <Stir time_spec="several minutes" vessel="filter"/>
+    settling_time: float            测完了能跑✅
 
 class StartStirProtocol(BaseModel):
     vessel: str
@@ -149,11 +169,11 @@ class TransferProtocol(BaseModel):
     volume: float
     amount: str = ""
     time: float = 0
-    viscous: bool = False    <Transfer from_vessel="main_reactor" to_vessel="rotavap"/>
+    viscous: bool = False   
     rinsing_solvent: str = ""
     rinsing_volume: float = 0.0
     rinsing_repeats: int = 0
-    solid: bool = False
+    solid: bool = False             这个protocol早该删掉了
 
 class CleanVesselProtocol(BaseModel):
     vessel: str
@@ -165,11 +185,11 @@ class CleanVesselProtocol(BaseModel):
 class DissolveProtocol(BaseModel):
     vessel: str
     solvent: str
-    volume: float   <Dissolve mass="2.9 g" mol="0.12 mol" reagent="magnesium" vessel="main_reactor"/>
-    amount: str = ""   
-    temp: float = 25.0
-    time: float = 0.0
-    stir_speed: float = 0.0
+    volume: float       <Dissolve mass="2.9 g" mol="0.12 mol" reagent="magnesium" vessel="main_reactor"/>
+    amount: str = ""    <Dissolve mass="12.9 g" reagent="4-tert-butylbenzyl bromide" vessel="main_reactor"/>
+    temp: float = 25.0  <Dissolve solvent="diisopropyl ether" vessel="rotavap" volume="?"/>
+    time: float = 0.0   <Dissolve event="A" mass="?" reagent="pyridinone" vessel="main_reactor"/>
+    stir_speed: float = 0.0     测完了能跑✅
 
 class FilterThroughProtocol(BaseModel):
     from_vessel: str
@@ -183,16 +203,19 @@ class FilterThroughProtocol(BaseModel):
 class RunColumnProtocol(BaseModel):
     from_vessel: str
     to_vessel: str              <RunColumn Rf="?" column="column" from_vessel="rotavap" pct1="40 %" pct2="50 %" solvent1="ethyl acetate" solvent2="hexane" to_vessel="rotavap"/>
-    column: str
+    column: str                 测完了能跑✅
 
 class WashSolidProtocol(BaseModel):
     vessel: str
     solvent: str
     volume: float
-    filtrate_vessel: str = ""
+    filtrate_vessel: str = ""   <WashSolid repeats="4" solvent="water" vessel="main_reactor" volume="400 mL"/>
     temp: float = 25.0          <WashSolid filtrate_vessel="rotavap" solvent="formic acid" vessel="main_reactor" volume="?"/>
-    stir: bool = False
-    stir_speed: float = 0.0
+    stir: bool = False          <WashSolid solvent="acetone" vessel="rotavap" volume="5 mL"/>
+                                <WashSolid solvent="ethyl alcohol" vessel="main_reactor" volume_spec="small volume"/>
+                                <WashSolid filtrate_vessel="rotavap" mass="10 g" solvent="toluene" vessel="separator"/>
+                                <WashSolid repeats_spec="several" solvent="water" vessel="main_reactor" volume="?"/>
+    stir_speed: float = 0.0     测完了能跑✅
     time: float = 0.0
     repeats: int = 1
 
@@ -219,4 +242,17 @@ class RecrystallizeProtocol(BaseModel):
 class HydrogenateProtocol(BaseModel):
     temp: str = Field(..., description="反应温度（如 '45 °C'）")
     time: str = Field(..., description="反应时间（如 '2 h'）")                          <新写的，没问题>
-    vessel: str = Field(..., description="反应容器")
+    vessel: str = Field(..., description="反应容器")
+
+    还差
+    <dissolve>
+    <separate>
+    <CleanVessel vessel="centrifuge"/>
+
+
+单位修复：
+    evaporate
+    heatchill
+    recrysitallize
+    stir
+    wash solid

test/experiments/comprehensive_protocol/comprehensive_station.json

@@ -32,7 +32,11 @@
                 "separator_1",
                 "collection_bottle_1",
                 "collection_bottle_2",
-                "collection_bottle_3"
+                "collection_bottle_3",
+                "solid_dispenser_1",
+                "solid_reagent_bottle_1",
+                "solid_reagent_bottle_2",
+                "solid_reagent_bottle_3"
             ],
             "parent": null,
             "type": "device",
@@ -672,6 +676,98 @@
             "data": {
                 "current_volume": 0.0
             }
+        },
+        {
+            "id": "solid_dispenser_1",
+            "name": "固体粉末加样器",
+            "children": [],
+            "parent": "OrganicSynthesisStation",
+            "type": "device",
+            "class": "virtual_solid_dispenser",
+            "position": {
+                "x": 600,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "max_capacity": 100.0,
+                "precision": 0.001
+            },
+            "data": {
+                "status": "Ready",
+                "current_reagent": "",
+                "dispensed_amount": 0.0,
+                "total_operations": 0
+            }
+        },
+        {
+            "id": "solid_reagent_bottle_1",
+            "name": "固体试剂瓶1-氯化钠",
+            "children": [],
+            "parent": "OrganicSynthesisStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 550,
+                "y": 250,
+                "z": 0
+            },
+            "config": {
+                "volume": 500.0,
+                "reagent": "sodium_chloride",
+                "physical_state": "solid"
+            },
+            "data": {
+                "current_mass": 500.0,
+                "reagent_name": "sodium_chloride",
+                "physical_state": "solid"
+            }
+        },
+        {
+            "id": "solid_reagent_bottle_2",
+            "name": "固体试剂瓶2-碳酸钠",
+            "children": [],
+            "parent": "OrganicSynthesisStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 600,
+                "y": 250,
+                "z": 0
+            },
+            "config": {
+                "volume": 500.0,
+                "reagent": "sodium_carbonate",
+                "physical_state": "solid"
+            },
+            "data": {
+                "current_mass": 500.0,
+                "reagent_name": "sodium_carbonate",
+                "physical_state": "solid"
+            }
+        },
+        {
+            "id": "solid_reagent_bottle_3",
+            "name": "固体试剂瓶3-氯化镁",
+            "children": [],
+            "parent": "OrganicSynthesisStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 650,
+                "y": 250,
+                "z": 0
+            },
+            "config": {
+                "volume": 500.0,
+                "reagent": "magnesium_chloride",
+                "physical_state": "solid"
+            },
+            "data": {
+                "current_mass": 500.0,
+                "reagent_name": "magnesium_chloride",
+                "physical_state": "solid"
+            }
         }
     ],
     "links": [
@@ -802,7 +898,7 @@
             "type": "fluid",
             "port": {
                 "multiway_valve_2": "3",
-                "solenoid_valve_2": "in"
+                "solenoid_valve_2": "out"
             }
         },
         {
@@ -812,7 +908,7 @@
             "type": "fluid",
             "port": {
                 "gas_source_1": "gassource",
-                "solenoid_valve_2": "out"
+                "solenoid_valve_2": "in"
             }
         },
         {
@@ -964,6 +1060,46 @@
                 "solenoid_valve_3": "out",
                 "main_reactor": "top"
             }
+        },
+        {
+            "id": "link_solid_dispenser_to_reactor",
+            "source": "solid_dispenser_1",
+            "target": "main_reactor",
+            "type": "resource",
+            "port": {
+                "solid_dispenser_1": "SolidOut",
+                "main_reactor": "top"
+            }
+        },
+        {
+            "id": "link_solid_bottle1_to_dispenser",
+            "source": "solid_reagent_bottle_1",
+            "target": "solid_dispenser_1",
+            "type": "resource",
+            "port": {
+                "solid_reagent_bottle_1": "top",
+                "solid_dispenser_1": "SolidIn"
+            }
+        },
+        {
+            "id": "link_solid_bottle2_to_dispenser",
+            "source": "solid_reagent_bottle_2",
+            "target": "solid_dispenser_1",
+            "type": "resource",
+            "port": {
+                "solid_reagent_bottle_2": "top",
+                "solid_dispenser_1": "SolidIn"
+            }
+        },
+        {
+            "id": "link_solid_bottle3_to_dispenser",
+            "source": "solid_reagent_bottle_3",
+            "target": "solid_dispenser_1",
+            "type": "resource",
+            "port": {
+                "solid_reagent_bottle_3": "top",
+                "solid_dispenser_1": "SolidIn"
+            }
         }
     ]
 }

test/experiments/prcxi.json

@@ -19,7 +19,8 @@
                 "host": "192.168.3.9",
                 "port": 9999,
                 "timeout": 10.0,
-                "setup": true
+                "setup": false,
+                "debug": true
             },
             "data": {},
             "children": [

unilabos/app/mq.py

@@ -166,7 +166,7 @@ class MQTTClient:
         status = {"data": device_status.get(device_id, {}), "device_id": device_id, "timestamp": time.time()}
         address = f"labs/{MQConfig.lab_id}/devices/"
         self.client.publish(address, json.dumps(status), qos=2)
-        logger.info(f"Device status published: address: {address}, {status}")
+        logger.debug(f"Device status published: address: {address}, {status}")
 
     def publish_job_status(self, feedback_data: dict, job_id: str, status: str, return_info: Optional[str] = None):
         if self.mqtt_disable:

unilabos/compile/adjustph_protocol.py

@@ -1,7 +1,30 @@
 import networkx as nx
+import logging
 from typing import List, Dict, Any
 from .pump_protocol import generate_pump_protocol_with_rinsing
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"[ADJUST_PH] {message}", flush=True)
+    logger.info(f"[ADJUST_PH] {message}")
+
+# 🆕 创建进度日志动作
+def create_action_log(message: str, emoji: str = "📝") -> Dict[str, Any]:
+    """创建一个动作日志"""
+    full_message = f"{emoji} {message}"
+    debug_print(full_message)
+    logger.info(full_message)
+    print(f"[ACTION] {full_message}", flush=True)
+    
+    return {
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 0.1,
+            "log_message": full_message
+        }
+    }
 
 def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
     """
@@ -14,7 +37,7 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
     Returns:
         str: 试剂容器ID
     """
-    print(f"ADJUST_PH: 正在查找试剂 '{reagent}' 的容器...")
+    debug_print(f"🔍 正在查找试剂 '{reagent}' 的容器...")
     
     # 常见酸碱试剂的别名映射
     reagent_aliases = {
@@ -29,11 +52,16 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
     
     # 构建搜索名称列表
     search_names = [reagent.lower()]
+    debug_print(f"📋 基础搜索名称: {reagent.lower()}")
     
     # 添加别名
     for base_name, aliases in reagent_aliases.items():
         if reagent.lower() in base_name.lower() or base_name.lower() in reagent.lower():
             search_names.extend([alias.lower() for alias in aliases])
+            debug_print(f"🔗 添加别名: {aliases}")
+            break
+    
+    debug_print(f"📝 完整搜索列表: {search_names}")
     
     # 构建可能的容器名称
     possible_names = []
@@ -49,13 +77,17 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
             name_clean
         ])
     
+    debug_print(f"🎯 可能的容器名称 (前5个): {possible_names[:5]}... (共{len(possible_names)}个)")
+    
     # 第一步：通过容器名称匹配
+    debug_print(f"📋 方法1: 精确名称匹配...")
     for vessel_name in possible_names:
         if vessel_name in G.nodes():
-            print(f"ADJUST_PH: 通过名称匹配找到容器: {vessel_name}")
+            debug_print(f"✅ 通过名称匹配找到容器: {vessel_name} 🎯")
             return vessel_name
     
     # 第二步：通过模糊匹配
+    debug_print(f"📋 方法2: 模糊名称匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             node_name = G.nodes[node_id].get('name', '').lower()
@@ -63,10 +95,11 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
             # 检查是否包含任何搜索名称
             for search_name in search_names:
                 if search_name in node_id.lower() or search_name in node_name:
-                    print(f"ADJUST_PH: 通过模糊匹配找到容器: {node_id}")
+                    debug_print(f"✅ 通过模糊匹配找到容器: {node_id} 🔍")
                     return node_id
     
     # 第三步：通过液体类型匹配
+    debug_print(f"📋 方法3: 液体类型匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             vessel_data = G.nodes[node_id].get('data', {})
@@ -79,10 +112,11 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
                     
                     for search_name in search_names:
                         if search_name in liquid_type or search_name in reagent_name:
-                            print(f"ADJUST_PH: 通过液体类型匹配找到容器: {node_id}")
+                            debug_print(f"✅ 通过液体类型匹配找到容器: {node_id} 💧")
                             return node_id
     
     # 列出可用容器帮助调试
+    debug_print(f"📊 列出可用容器帮助调试...")
     available_containers = []
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
@@ -98,67 +132,92 @@ def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
                 'reagent_name': vessel_data.get('reagent_name', '')
             })
     
-    print(f"ADJUST_PH: 可用容器列表:")
+    debug_print(f"📋 可用容器列表:")
     for container in available_containers:
-        print(f"  - {container['id']}: {container['name']}")
-        print(f"    液体: {container['liquids']}")
-        print(f"    试剂: {container['reagent_name']}")
+        debug_print(f"  - 🧪 {container['id']}: {container['name']}")
+        debug_print(f"    💧 液体: {container['liquids']}")
+        debug_print(f"    🏷️ 试剂: {container['reagent_name']}")
     
-    raise ValueError(f"找不到试剂 '{reagent}' 对应的容器。尝试了: {possible_names}")
-
+    debug_print(f"❌ 所有匹配方法都失败了")
+    raise ValueError(f"找不到试剂 '{reagent}' 对应的容器。尝试了: {possible_names[:10]}...")
 
 def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
     """查找与容器相连的搅拌器"""
+    debug_print(f"🔍 查找连接到容器 '{vessel}' 的搅拌器...")
+    
     stirrer_nodes = [node for node in G.nodes() 
                     if (G.nodes[node].get('class') or '') == 'virtual_stirrer']
     
+    debug_print(f"📊 发现 {len(stirrer_nodes)} 个搅拌器: {stirrer_nodes}")
+    
     for stirrer in stirrer_nodes:
         if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer} 🔗")
             return stirrer
     
-    return stirrer_nodes[0] if stirrer_nodes else None
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个: {stirrer_nodes[0]} 🔄")
+        return stirrer_nodes[0]
+    
+    debug_print(f"❌ 未找到任何搅拌器")
+    return None
 
-
-def calculate_reagent_volume(target_ph_value: float, reagent: str, vessel_volume: float = 100.0) -> float:  # 改为 target_ph_value
+def calculate_reagent_volume(target_ph_value: float, reagent: str, vessel_volume: float = 100.0) -> float:
     """
     估算需要的试剂体积来调节pH
     
     Args:
-        target_ph_value: 目标pH值  # 改为 target_ph_value
+        target_ph_value: 目标pH值
         reagent: 试剂名称
         vessel_volume: 容器体积 (mL)
     
     Returns:
         float: 估算的试剂体积 (mL)
     """
+    debug_print(f"🧮 计算试剂体积...")
+    debug_print(f"  📍 目标pH: {target_ph_value}")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 容器体积: {vessel_volume}mL")
+    
     # 简化的pH调节体积估算（实际应用中需要更精确的计算）
     if "acid" in reagent.lower() or "hcl" in reagent.lower():
+        debug_print(f"🍋 检测到酸性试剂")
         # 酸性试剂：pH越低需要的体积越大
-        if target_ph_value < 3:  # 改为 target_ph_value
-            return vessel_volume * 0.05  # 5%
-        elif target_ph_value < 5:  # 改为 target_ph_value
-            return vessel_volume * 0.02  # 2%
+        if target_ph_value < 3:
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强酸性 (pH<3): 使用 5% 体积")
+        elif target_ph_value < 5:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中酸性 (pH<5): 使用 2% 体积")
         else:
-            return vessel_volume * 0.01  # 1%
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱酸性 (pH≥5): 使用 1% 体积")
     
     elif "hydroxide" in reagent.lower() or "naoh" in reagent.lower():
+        debug_print(f"🧂 检测到碱性试剂")
         # 碱性试剂：pH越高需要的体积越大
-        if target_ph_value > 11:  # 改为 target_ph_value
-            return vessel_volume * 0.05  # 5%
-        elif target_ph_value > 9:  # 改为 target_ph_value
-            return vessel_volume * 0.02  # 2%
+        if target_ph_value > 11:
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强碱性 (pH>11): 使用 5% 体积")
+        elif target_ph_value > 9:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中碱性 (pH>9): 使用 2% 体积")
         else:
-            return vessel_volume * 0.01  # 1%
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱碱性 (pH≤9): 使用 1% 体积")
     
     else:
         # 未知试剂，使用默认值
-        return vessel_volume * 0.01
-
+        volume = vessel_volume * 0.01
+        debug_print(f"❓ 未知试剂类型，使用默认 1% 体积")
+    
+    debug_print(f"📊 计算结果: {volume:.2f}mL")
+    return volume
 
 def generate_adjust_ph_protocol(
     G: nx.DiGraph,
     vessel: str,
-    ph_value: float,  # 改为 ph_value
+    ph_value: float,
     reagent: str,
     **kwargs
 ) -> List[Dict[str, Any]]:
@@ -168,13 +227,23 @@ def generate_adjust_ph_protocol(
     Args:
         G: 有向图，节点为容器和设备
         vessel: 目标容器（需要调节pH的容器）
-        ph_value: 目标pH值（从XDL传入）  # 改为 ph_value
+        ph_value: 目标pH值（从XDL传入）
         reagent: 酸碱试剂名称（从XDL传入）
         **kwargs: 其他可选参数，使用默认值
     
     Returns:
         List[Dict[str, Any]]: 动作序列
     """
+    
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成pH调节协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: '{vessel}'")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: '{reagent}'")
+    debug_print(f"  📦 kwargs: {kwargs}")
+    debug_print("=" * 60)
+    
     action_sequence = []
     
     # 从kwargs中获取可选参数，如果没有则使用默认值
@@ -184,48 +253,84 @@ def generate_adjust_ph_protocol(
     stir_time = kwargs.get('stir_time', 60.0)    # 默认搅拌时间
     settling_time = kwargs.get('settling_time', 30.0)  # 默认平衡时间
     
-    print(f"ADJUST_PH: 开始生成pH调节协议")
-    print(f"  - 目标容器: {vessel}")
-    print(f"  - 目标pH: {ph_value}")  # 改为 ph_value
-    print(f"  - 试剂: {reagent}")
-    print(f"  - 使用默认参数: 体积=自动估算, 搅拌=True, 搅拌速度=300RPM")
+    debug_print(f"🔧 处理后的参数:")
+    debug_print(f"  📏 volume: {volume}mL (0.0表示自动估算)")
+    debug_print(f"  🌪️ stir: {stir}")
+    debug_print(f"  🔄 stir_speed: {stir_speed}rpm")
+    debug_print(f"  ⏱️ stir_time: {stir_time}s")
+    debug_print(f"  ⏳ settling_time: {settling_time}s")
+    
+    # 开始处理
+    action_sequence.append(create_action_log(f"开始调节pH至 {ph_value}", "🧪"))
+    action_sequence.append(create_action_log(f"目标容器: {vessel}", "🥼"))
+    action_sequence.append(create_action_log(f"使用试剂: {reagent}", "⚗️"))
     
     # 1. 验证目标容器存在
+    debug_print(f"🔍 步骤1: 验证目标容器...")
     if vessel not in G.nodes():
+        debug_print(f"❌ 目标容器 '{vessel}' 不存在于系统中")
         raise ValueError(f"目标容器 '{vessel}' 不存在于系统中")
     
+    debug_print(f"✅ 目标容器验证通过")
+    action_sequence.append(create_action_log("目标容器验证通过", "✅"))
+    
     # 2. 查找酸碱试剂容器
+    debug_print(f"🔍 步骤2: 查找试剂容器...")
+    action_sequence.append(create_action_log("正在查找试剂容器...", "🔍"))
+    
     try:
         reagent_vessel = find_acid_base_vessel(G, reagent)
-        print(f"ADJUST_PH: 找到试剂容器: {reagent_vessel}")
+        debug_print(f"✅ 找到试剂容器: {reagent_vessel}")
+        action_sequence.append(create_action_log(f"找到试剂容器: {reagent_vessel}", "🧪"))
     except ValueError as e:
+        debug_print(f"❌ 无法找到试剂容器: {str(e)}")
+        action_sequence.append(create_action_log(f"试剂容器查找失败: {str(e)}", "❌"))
         raise ValueError(f"无法找到试剂 '{reagent}': {str(e)}")
     
-    # 3. 如果未指定体积，自动估算
+    # 3. 体积估算
+    debug_print(f"🔍 步骤3: 体积处理...")
     if volume <= 0:
+        action_sequence.append(create_action_log("开始自动估算试剂体积", "🧮"))
+        
         # 获取目标容器的体积信息
         vessel_data = G.nodes[vessel].get('data', {})
         vessel_volume = vessel_data.get('max_volume', 100.0)  # 默认100mL
+        debug_print(f"📏 容器最大体积: {vessel_volume}mL")
         
-        estimated_volume = calculate_reagent_volume(ph_value, reagent, vessel_volume)  # 改为 ph_value
+        estimated_volume = calculate_reagent_volume(ph_value, reagent, vessel_volume)
         volume = estimated_volume
-        print(f"ADJUST_PH: 自动估算试剂体积: {volume:.2f} mL")
+        debug_print(f"✅ 自动估算试剂体积: {volume:.2f} mL")
+        action_sequence.append(create_action_log(f"估算试剂体积: {volume:.2f}mL", "📊"))
+    else:
+        debug_print(f"📏 使用指定体积: {volume}mL")
+        action_sequence.append(create_action_log(f"使用指定体积: {volume}mL", "📏"))
     
     # 4. 验证路径存在
+    debug_print(f"🔍 步骤4: 路径验证...")
+    action_sequence.append(create_action_log("验证转移路径...", "🛤️"))
+    
     try:
         path = nx.shortest_path(G, source=reagent_vessel, target=vessel)
-        print(f"ADJUST_PH: 找到路径: {' → '.join(path)}")
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"找到转移路径: {' → '.join(path)}", "🛤️"))
     except nx.NetworkXNoPath:
+        debug_print(f"❌ 无法找到转移路径")
+        action_sequence.append(create_action_log("转移路径不存在", "❌"))
         raise ValueError(f"从试剂容器 '{reagent_vessel}' 到目标容器 '{vessel}' 没有可用路径")
     
-    # 5. 先启动搅拌（如果需要）
+    # 5. 搅拌器设置
+    debug_print(f"🔍 步骤5: 搅拌器设置...")
     stirrer_id = None
     if stir:
+        action_sequence.append(create_action_log("准备启动搅拌器", "🌪️"))
+        
         try:
             stirrer_id = find_connected_stirrer(G, vessel)
             
             if stirrer_id:
-                print(f"ADJUST_PH: 找到搅拌器 {stirrer_id}，启动搅拌")
+                debug_print(f"✅ 找到搅拌器 {stirrer_id}，启动搅拌")
+                action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed}rpm)", "🔄"))
+                
                 action_sequence.append({
                     "device_id": stirrer_id,
                     "action_name": "start_stir",
@@ -237,23 +342,34 @@ def generate_adjust_ph_protocol(
                 })
                 
                 # 等待搅拌稳定
+                action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
                 action_sequence.append({
                     "action_name": "wait",
                     "action_kwargs": {"time": 5}
                 })
             else:
-                print(f"ADJUST_PH: 警告 - 未找到搅拌器，继续执行")
+                debug_print(f"⚠️ 未找到搅拌器，继续执行")
+                action_sequence.append(create_action_log("未找到搅拌器，跳过搅拌", "⚠️"))
         
         except Exception as e:
-            print(f"ADJUST_PH: 搅拌器配置出错: {str(e)}")
+            debug_print(f"❌ 搅拌器配置出错: {str(e)}")
+            action_sequence.append(create_action_log(f"搅拌器配置失败: {str(e)}", "❌"))
+    else:
+        debug_print(f"📋 跳过搅拌设置")
+        action_sequence.append(create_action_log("跳过搅拌设置", "⏭️"))
     
-    # 6. 缓慢添加试剂 - 使用pump_protocol
-    print(f"ADJUST_PH: 开始添加试剂 {volume:.2f} mL")
+    # 6. 试剂添加
+    debug_print(f"🔍 步骤6: 试剂添加...")
+    action_sequence.append(create_action_log(f"开始添加试剂 {volume:.2f}mL", "🚰"))
     
     # 计算添加时间（pH调节需要缓慢添加）
     addition_time = max(30.0, volume * 2.0)  # 至少30秒，每mL需要2秒
+    debug_print(f"⏱️ 计算添加时间: {addition_time}s (缓慢注入)")
+    action_sequence.append(create_action_log(f"设置添加时间: {addition_time:.0f}s (缓慢注入)", "⏱️"))
     
     try:
+        action_sequence.append(create_action_log("调用泵协议进行试剂转移", "🔄"))
+        
         pump_actions = generate_pump_protocol_with_rinsing(
             G=G,
             from_vessel=reagent_vessel,
@@ -266,17 +382,24 @@ def generate_adjust_ph_protocol(
             rinsing_volume=0.0,
             rinsing_repeats=0,
             solid=False,
-            flowrate=0.5  # 缓慢注入
+            flowrate=0.5,  # 缓慢注入
+            transfer_flowrate=0.3
         )
         
         action_sequence.extend(pump_actions)
+        debug_print(f"✅ 泵协议生成完成，添加了 {len(pump_actions)} 个动作")
+        action_sequence.append(create_action_log(f"试剂转移完成 ({len(pump_actions)} 个操作)", "✅"))
         
     except Exception as e:
+        debug_print(f"❌ 生成泵协议时出错: {str(e)}")
+        action_sequence.append(create_action_log(f"泵协议生成失败: {str(e)}", "❌"))
         raise ValueError(f"生成泵协议时出错: {str(e)}")
     
-    # 7. 持续搅拌以混合和平衡
+    # 7. 混合搅拌
     if stir and stirrer_id:
-        print(f"ADJUST_PH: 持续搅拌 {stir_time} 秒以混合试剂")
+        debug_print(f"🔍 步骤7: 混合搅拌...")
+        action_sequence.append(create_action_log(f"开始混合搅拌 {stir_time:.0f}s", "🌀"))
+        
         action_sequence.append({
             "device_id": stirrer_id,
             "action_name": "stir",
@@ -284,25 +407,47 @@ def generate_adjust_ph_protocol(
                 "stir_time": stir_time,
                 "stir_speed": stir_speed,
                 "settling_time": settling_time,
-                "purpose": f"pH调节: 混合试剂，目标pH={ph_value}"  # 改为 ph_value
+                "purpose": f"pH调节: 混合试剂，目标pH={ph_value}"
             }
         })
+        
+        debug_print(f"✅ 混合搅拌设置完成")
+    else:
+        debug_print(f"⏭️ 跳过混合搅拌")
+        action_sequence.append(create_action_log("跳过混合搅拌", "⏭️"))
+    
+    # 8. 等待平衡
+    debug_print(f"🔍 步骤8: 反应平衡...")
+    action_sequence.append(create_action_log(f"等待pH平衡 {settling_time:.0f}s", "⚖️"))
     
-    # 8. 等待反应平衡
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
             "time": settling_time,
-            "description": f"等待pH平衡到目标值 {ph_value}"  # 改为 ph_value
+            "description": f"等待pH平衡到目标值 {ph_value}"
         }
     })
     
-    print(f"ADJUST_PH: 协议生成完成，共 {len(action_sequence)} 个动作")
-    print(f"ADJUST_PH: 预计总时间: {addition_time + stir_time + settling_time:.0f} 秒")
+    # 9. 完成总结
+    total_time = addition_time + stir_time + settling_time
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 pH调节协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f}分钟)")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 体积: {volume:.2f}mL")
+    debug_print(f"  📊 目标pH: {ph_value}")
+    debug_print(f"  🥼 目标容器: {vessel}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"pH调节协议完成: {vessel} → pH {ph_value} (使用 {volume:.2f}mL {reagent})"
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
     
     return action_sequence
 
-
 def generate_adjust_ph_protocol_stepwise(
     G: nx.DiGraph,
     vessel: str,
@@ -317,7 +462,7 @@ def generate_adjust_ph_protocol_stepwise(
     Args:
         G: 网络图
         vessel: 目标容器
-        pH: 目标pH值
+        ph_value: 目标pH值
         reagent: 酸碱试剂
         max_volume: 最大试剂体积
         steps: 分步数量
@@ -325,15 +470,28 @@ def generate_adjust_ph_protocol_stepwise(
     Returns:
         List[Dict[str, Any]]: 动作序列
     """
-    action_sequence = []
+    debug_print("=" * 60)
+    debug_print(f"🔄 开始分步pH调节")
+    debug_print(f"📋 分步参数:")
+    debug_print(f"  🥼 vessel: {vessel}")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: {reagent}")
+    debug_print(f"  📏 max_volume: {max_volume}mL")
+    debug_print(f"  🔢 steps: {steps}")
+    debug_print("=" * 60)
     
-    print(f"ADJUST_PH: 开始分步pH调节（{steps}步）")
+    action_sequence = []
     
     # 每步添加的体积
     step_volume = max_volume / steps
+    debug_print(f"📊 每步体积: {step_volume:.2f}mL")
+    
+    action_sequence.append(create_action_log(f"开始分步pH调节 ({steps}步)", "🔄"))
+    action_sequence.append(create_action_log(f"每步添加: {step_volume:.2f}mL", "📏"))
     
     for i in range(steps):
-        print(f"ADJUST_PH: 第 {i+1}/{steps} 步，添加 {step_volume} mL")
+        debug_print(f"🔄 执行第 {i+1}/{steps} 步，添加 {step_volume:.2f}mL")
+        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步开始", "🚀"))
         
         # 生成单步协议
         step_actions = generate_adjust_ph_protocol(
@@ -349,9 +507,13 @@ def generate_adjust_ph_protocol_stepwise(
         )
         
         action_sequence.extend(step_actions)
+        debug_print(f"✅ 第 {i+1}/{steps} 步完成，添加了 {len(step_actions)} 个动作")
+        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步完成", "✅"))
         
         # 步骤间等待
         if i < steps - 1:
+            debug_print(f"⏳ 步骤间等待30s")
+            action_sequence.append(create_action_log("步骤间等待...", "⏳"))
             action_sequence.append({
                 "action_name": "wait",
                 "action_kwargs": {
@@ -360,10 +522,11 @@ def generate_adjust_ph_protocol_stepwise(
                 }
             })
     
-    print(f"ADJUST_PH: 分步pH调节完成")
+    debug_print(f"🎉 分步pH调节完成，共 {len(action_sequence)} 个动作")
+    action_sequence.append(create_action_log("分步pH调节全部完成", "🎉"))
+    
     return action_sequence
 
-
 # 便捷函数：常用pH调节
 def generate_acidify_protocol(
     G: nx.DiGraph,
@@ -372,11 +535,11 @@ def generate_acidify_protocol(
     acid: str = "hydrochloric acid"
 ) -> List[Dict[str, Any]]:
     """酸化协议"""
+    debug_print(f"🍋 生成酸化协议: {vessel} → pH {target_ph} (使用 {acid})")
     return generate_adjust_ph_protocol(
-        G, vessel, target_ph, acid, 0.0, True, 300.0, 120.0, 60.0
+        G, vessel, target_ph, acid
     )
 
-
 def generate_basify_protocol(
     G: nx.DiGraph,
     vessel: str,
@@ -384,28 +547,42 @@ def generate_basify_protocol(
     base: str = "sodium hydroxide"
 ) -> List[Dict[str, Any]]:
     """碱化协议"""
+    debug_print(f"🧂 生成碱化协议: {vessel} → pH {target_ph} (使用 {base})")
     return generate_adjust_ph_protocol(
-        G, vessel, target_ph, base, 0.0, True, 300.0, 120.0, 60.0
+        G, vessel, target_ph, base
     )
 
-
 def generate_neutralize_protocol(
     G: nx.DiGraph,
     vessel: str,
     reagent: str = "sodium hydroxide"
 ) -> List[Dict[str, Any]]:
     """中和协议（pH=7）"""
+    debug_print(f"⚖️ 生成中和协议: {vessel} → pH 7.0 (使用 {reagent})")
     return generate_adjust_ph_protocol(
-        G, vessel, 7.0, reagent, 0.0, True, 350.0, 180.0, 90.0
+        G, vessel, 7.0, reagent
     )
 
-
 # 测试函数
 def test_adjust_ph_protocol():
     """测试pH调节协议"""
-    print("=== ADJUST PH PROTOCOL 测试 ===")
-    print("测试完成")
-
+    debug_print("=== ADJUST PH PROTOCOL 增强版测试 ===")
+    
+    # 测试体积计算
+    debug_print("🧮 测试体积计算...")
+    test_cases = [
+        (2.0, "hydrochloric acid", 100.0),
+        (4.0, "hydrochloric acid", 100.0),
+        (12.0, "sodium hydroxide", 100.0),
+        (10.0, "sodium hydroxide", 100.0),
+        (7.0, "unknown reagent", 100.0)
+    ]
+    
+    for ph, reagent, volume in test_cases:
+        result = calculate_reagent_volume(ph, reagent, volume)
+        debug_print(f"📊 {reagent} → pH {ph}: {result:.2f}mL")
+    
+    debug_print("✅ 测试完成")
 
 if __name__ == "__main__":
     test_adjust_ph_protocol()

unilabos/compile/dry_protocol.py

@@ -67,37 +67,47 @@ def generate_dry_protocol(
     # 默认参数
     dry_temp = 60.0  # 默认干燥温度 60°C
     dry_time = 3600.0  # 默认干燥时间 1小时（3600秒）
+    simulation_time = 60.0  # 模拟时间 1分钟
     
-    print(f"DRY: 开始生成干燥协议")
-    print(f"  - 化合物: {compound}")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 干燥温度: {dry_temp}°C")
-    print(f"  - 干燥时间: {dry_time/60:.0f} 分钟")
+    print(f"🌡️ DRY: 开始生成干燥协议 ✨")
+    print(f"  🧪 化合物: {compound}")
+    print(f"  🥽 容器: {vessel}")
+    print(f"  🔥 干燥温度: {dry_temp}°C")
+    print(f"  ⏰ 干燥时间: {dry_time/60:.0f} 分钟")
     
     # 1. 验证目标容器存在
+    print(f"\n📋 步骤1: 验证目标容器 '{vessel}' 是否存在...")
     if vessel not in G.nodes():
-        print(f"DRY: 警告 - 容器 '{vessel}' 不存在于系统中，跳过干燥")
+        print(f"⚠️ DRY: 警告 - 容器 '{vessel}' 不存在于系统中，跳过干燥 😢")
         return action_sequence
+    print(f"✅ 容器 '{vessel}' 验证通过!")
     
     # 2. 查找相连的加热器
+    print(f"\n🔍 步骤2: 查找与容器相连的加热器...")
     heater_id = find_connected_heater(G, vessel)
     
     if heater_id is None:
-        print(f"DRY: 警告 - 未找到与容器 '{vessel}' 相连的加热器，跳过干燥")
+        print(f"😭 DRY: 警告 - 未找到与容器 '{vessel}' 相连的加热器，跳过干燥")
+        print(f"🎭 添加模拟干燥动作...")
         # 添加一个等待动作，表示干燥过程（模拟）
         action_sequence.append({
             "action_name": "wait",
             "action_kwargs": {
-                "time": 60.0,  # 等待1分钟
+                "time": 10.0,  # 模拟等待时间
                 "description": f"模拟干燥 {compound} (无加热器可用)"
             }
         })
+        print(f"📄 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
         return action_sequence
     
+    print(f"🎉 找到加热器: {heater_id}!")
+    
     # 3. 启动加热器进行干燥
-    print(f"DRY: 启动加热器 {heater_id} 进行干燥")
+    print(f"\n🚀 步骤3: 开始执行干燥流程...")
+    print(f"🔥 启动加热器 {heater_id} 进行干燥")
     
     # 3.1 启动加热
+    print(f"  ⚡ 动作1: 启动加热到 {dry_temp}°C...")
     action_sequence.append({
         "device_id": heater_id,
         "action_name": "heat_chill_start",
@@ -107,29 +117,35 @@ def generate_dry_protocol(
             "purpose": f"干燥 {compound}"
         }
     })
+    print(f"  ✅ 加热器启动命令已添加 🔥")
     
     # 3.2 等待温度稳定
+    print(f"  ⏳ 动作2: 等待温度稳定...")
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 60.0,
+            "time": 10.0,
             "description": f"等待温度稳定到 {dry_temp}°C"
         }
     })
+    print(f"  ✅ 温度稳定等待命令已添加 🌡️")
     
     # 3.3 保持干燥温度
+    print(f"  🔄 动作3: 保持干燥温度 {simulation_time/60:.0f} 分钟...")
     action_sequence.append({
         "device_id": heater_id,
         "action_name": "heat_chill",
         "action_kwargs": {
             "vessel": vessel,
             "temp": dry_temp,
-            "time": dry_time,
+            "time": simulation_time,
             "purpose": f"干燥 {compound}，保持温度 {dry_temp}°C"
         }
     })
+    print(f"  ✅ 温度保持命令已添加 🌡️⏰")
     
     # 3.4 停止加热
+    print(f"  ⏹️ 动作4: 停止加热...")
     action_sequence.append({
         "device_id": heater_id,
         "action_name": "heat_chill_stop",
@@ -138,18 +154,22 @@ def generate_dry_protocol(
             "purpose": f"干燥完成，停止加热"
         }
     })
+    print(f"  ✅ 停止加热命令已添加 🛑")
     
     # 3.5 等待冷却
+    print(f"  ❄️ 动作5: 等待冷却...")
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 300.0,  # 等待5分钟冷却
+            "time": 10.0,  # 等待10秒冷却
             "description": f"等待 {compound} 冷却"
         }
     })
+    print(f"  ✅ 冷却等待命令已添加 🧊")
     
-    print(f"DRY: 协议生成完成，共 {len(action_sequence)} 个动作")
-    print(f"DRY: 预计总时间: {(dry_time + 360)/60:.0f} 分钟")
+    print(f"\n🎊 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
+    print(f"⏱️ DRY: 预计总时间: {(dry_time + 360)/60:.0f} 分钟 ⌛")
+    print(f"🏁 所有动作序列准备就绪! ✨")
     
     return action_sequence
 

unilabos/compile/evaporate_protocol.py

@@ -1,326 +1,366 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional, Union
 import networkx as nx
-from .pump_protocol import generate_pump_protocol
+import logging
+import re
 
+logger = logging.getLogger(__name__)
 
-def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+def debug_print(message):
+    """调试输出"""
+    print(f"🧪 [EVAPORATE] {message}", flush=True)
+    logger.info(f"[EVAPORATE] {message}")
+
+def parse_time_input(time_input: Union[str, float]) -> float:
     """
-    获取容器中的液体体积
+    解析时间输入，支持带单位的字符串
+    
+    Args:
+        time_input: 时间输入（如 "3 min", "180", "0.5 h" 等）
+    
+    Returns:
+        float: 时间（秒）
     """
-    if vessel not in G.nodes():
-        return 0.0
+    if isinstance(time_input, (int, float)):
+        debug_print(f"⏱️ 时间输入为数字: {time_input}s ✨")
+        return float(time_input)
     
-    vessel_data = G.nodes[vessel].get('data', {})
-    liquids = vessel_data.get('liquid', [])
+    if not time_input or not str(time_input).strip():
+        debug_print(f"⚠️ 时间输入为空，使用默认值: 180s (3分钟) 🕐")
+        return 180.0  # 默认3分钟
     
-    total_volume = 0.0
-    for liquid in liquids:
-        if isinstance(liquid, dict) and 'liquid_volume' in liquid:
-            total_volume += liquid['liquid_volume']
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间输入: '{time_str}' 📝")
     
-    return total_volume
+    # 处理未知时间
+    if time_str in ['?', 'unknown', 'tbd']:
+        default_time = 180.0  # 默认3分钟
+        debug_print(f"❓ 检测到未知时间，使用默认值: {default_time}s (3分钟) 🤷‍♀️")
+        return default_time
+    
+    # 移除空格并提取数字和单位
+    time_clean = re.sub(r'\s+', '', time_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(s|sec|second|min|minute|h|hr|hour|d|day)?', time_clean)
+    
+    if not match:
+        # 如果无法解析，尝试直接转换为数字（默认秒）
+        try:
+            value = float(time_str)
+            debug_print(f"✅ 时间解析成功: {time_str} → {value}s（无单位，默认秒）⏰")
+            return value
+        except ValueError:
+            debug_print(f"❌ 无法解析时间: '{time_str}'，使用默认值180s (3分钟) 😅")
+            return 180.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 's'  # 默认单位为秒
+    
+    # 转换为秒
+    if unit in ['min', 'minute']:
+        time_sec = value * 60.0  # min -> s
+        debug_print(f"🕐 时间转换: {value} 分钟 → {time_sec}s ⏰")
+    elif unit in ['h', 'hr', 'hour']:
+        time_sec = value * 3600.0  # h -> s
+        debug_print(f"🕐 时间转换: {value} 小时 → {time_sec}s ({time_sec/60:.1f}分钟) ⏰")
+    elif unit in ['d', 'day']:
+        time_sec = value * 86400.0  # d -> s
+        debug_print(f"🕐 时间转换: {value} 天 → {time_sec}s ({time_sec/3600:.1f}小时) ⏰")
+    else:  # s, sec, second 或默认
+        time_sec = value  # 已经是s
+        debug_print(f"🕐 时间转换: {value}s → {time_sec}s (已是秒) ⏰")
+    
+    return time_sec
 
+def find_rotavap_device(G: nx.DiGraph, vessel: str = None) -> Optional[str]:
+    """
+    在组态图中查找旋转蒸发仪设备
+    
+    Args:
+        G: 设备图
+        vessel: 指定的设备名称（可选）
+    
+    Returns:
+        str: 找到的旋转蒸发仪设备ID，如果没找到返回None
+    """
+    debug_print("🔍 开始查找旋转蒸发仪设备... 🌪️")
+    
+    # 如果指定了vessel，先检查是否存在且是旋转蒸发仪
+    if vessel:
+        debug_print(f"🎯 检查指定设备: {vessel} 🔧")
+        if vessel in G.nodes():
+            node_data = G.nodes[vessel]
+            node_class = node_data.get('class', '')
+            node_type = node_data.get('type', '')
+            
+            debug_print(f"📋 设备信息 {vessel}: class={node_class}, type={node_type}")
+            
+            # 检查是否为旋转蒸发仪
+            if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+                debug_print(f"🎉 找到指定的旋转蒸发仪: {vessel} ✨")
+                return vessel
+            elif node_type == 'device':
+                debug_print(f"✅ 指定设备存在，尝试直接使用: {vessel} 🔧")
+                return vessel
+        else:
+            debug_print(f"❌ 指定的设备 {vessel} 不存在 😞")
+    
+    # 在所有设备中查找旋转蒸发仪
+    debug_print("🔎 在所有设备中搜索旋转蒸发仪... 🕵️‍♀️")
+    rotavap_candidates = []
+    
+    for node_id, node_data in G.nodes(data=True):
+        node_class = node_data.get('class', '')
+        node_type = node_data.get('type', '')
+        
+        # 跳过非设备节点
+        if node_type != 'device':
+            continue
+            
+        # 检查设备类型
+        if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+            rotavap_candidates.append(node_id)
+            debug_print(f"🌟 找到旋转蒸发仪候选: {node_id} (class: {node_class}) 🌪️")
+        elif any(keyword in str(node_id).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+            rotavap_candidates.append(node_id)
+            debug_print(f"🌟 找到旋转蒸发仪候选 (按名称): {node_id} 🌪️")
+    
+    if rotavap_candidates:
+        selected = rotavap_candidates[0]  # 选择第一个找到的
+        debug_print(f"🎯 选择旋转蒸发仪: {selected} 🏆")
+        return selected
+    
+    debug_print("😭 未找到旋转蒸发仪设备 💔")
+    return None
 
-def find_rotavap_device(G: nx.DiGraph) -> str:
-    """查找旋转蒸发仪设备"""
-    rotavap_nodes = [node for node in G.nodes() 
-                    if (G.nodes[node].get('class') or '') == 'virtual_rotavap']
+def find_connected_vessel(G: nx.DiGraph, rotavap_device: str) -> Optional[str]:
+    """
+    查找与旋转蒸发仪连接的容器
     
-    if rotavap_nodes:
-        return rotavap_nodes[0]
+    Args:
+        G: 设备图
+        rotavap_device: 旋转蒸发仪设备ID
     
-    raise ValueError("系统中未找到旋转蒸发仪设备")
-
-
-def find_solvent_recovery_vessel(G: nx.DiGraph) -> str:
-    """查找溶剂回收容器"""
-    possible_names = [
-        "flask_distillate",
-        "bottle_distillate", 
-        "vessel_distillate",
-        "distillate",
-        "solvent_recovery",
-        "flask_solvent_recovery",
-        "collection_flask"
-    ]
+    Returns:
+        str: 连接的容器ID，如果没找到返回None
+    """
+    debug_print(f"🔗 查找与 {rotavap_device} 连接的容器... 🥽")
     
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    # 查看旋转蒸发仪的子设备
+    rotavap_data = G.nodes[rotavap_device]
+    children = rotavap_data.get('children', [])
     
-    # 如果找不到专门的回收容器，使用废液容器
-    waste_names = ["waste_workup", "flask_waste", "bottle_waste", "waste"]
-    for vessel_name in waste_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    debug_print(f"👶 检查子设备: {children}")
+    for child_id in children:
+        if child_id in G.nodes():
+            child_data = G.nodes[child_id]
+            child_type = child_data.get('type', '')
+            
+            if child_type == 'container':
+                debug_print(f"🎉 找到连接的容器: {child_id} 🥽✨")
+                return child_id
     
-    raise ValueError(f"未找到溶剂回收容器。尝试了以下名称: {possible_names + waste_names}")
-
+    # 查看邻接的容器
+    debug_print("🤝 检查邻接设备...")
+    for neighbor in G.neighbors(rotavap_device):
+        neighbor_data = G.nodes[neighbor]
+        neighbor_type = neighbor_data.get('type', '')
+        
+        if neighbor_type == 'container':
+            debug_print(f"🎉 找到邻接的容器: {neighbor} 🥽✨")
+            return neighbor
+    
+    debug_print("😞 未找到连接的容器 💔")
+    return None
 
 def generate_evaporate_protocol(
     G: nx.DiGraph,
     vessel: str,
     pressure: float = 0.1,
     temp: float = 60.0,
-    time: float = 1800.0,
-    stir_speed: float = 100.0
+    time: Union[str, float] = "180",     # 🔧 修改：支持字符串时间
+    stir_speed: float = 100.0,
+    solvent: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成蒸发操作的协议序列
-    
-    蒸发流程：
-    1. 液体转移：将待蒸发溶液从源容器转移到旋转蒸发仪
-    2. 蒸发操作：执行旋转蒸发
-    3. (可选) 溶剂回收：将冷凝的溶剂转移到回收容器
-    4. 残留物转移：将浓缩物从旋转蒸发仪转移回原容器或新容器
+    生成蒸发操作的协议序列 - 支持单位
     
     Args:
-        G: 有向图，节点为设备和容器，边为流体管道
-        vessel: 包含待蒸发溶液的容器名称
-        pressure: 蒸发时的真空度 (bar)，默认0.1 bar
-        temp: 蒸发时的加热温度 (°C)，默认60°C  
-        time: 蒸发时间 (秒)，默认1800秒(30分钟)
-        stir_speed: 旋转速度 (RPM)，默认100 RPM
+        G: 设备图
+        vessel: 容器名称或旋转蒸发仪名称
+        pressure: 真空度 (bar)，默认0.1
+        temp: 加热温度 (°C)，默认60
+        time: 蒸发时间（支持 "3 min", "180", "0.5 h" 等）
+        stir_speed: 旋转速度 (RPM)，默认100
+        solvent: 溶剂名称（用于参数优化）
+        **kwargs: 其他参数（兼容性）
     
     Returns:
-        List[Dict[str, Any]]: 蒸发操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到必要的设备时抛出异常
-    
-    Examples:
-        evaporate_actions = generate_evaporate_protocol(G, "reaction_mixture", 0.05, 80.0, 3600.0)
+        List[Dict[str, Any]]: 动作序列
     """
+    
+    debug_print("🌟" * 20)
+    debug_print("🌪️ 开始生成蒸发协议（支持单位）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel}")
+    debug_print(f"  💨 pressure: {pressure} bar")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time} (类型: {type(time)})")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  🧪 solvent: '{solvent}'")
+    debug_print("🌟" * 20)
+    
+    # === 步骤1: 查找旋转蒸发仪设备 ===
+    debug_print("📍 步骤1: 查找旋转蒸发仪设备... 🔍")
+    
+    # 验证vessel参数
+    if not vessel:
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    # 查找旋转蒸发仪设备
+    rotavap_device = find_rotavap_device(G, vessel)
+    if not rotavap_device:
+        debug_print("💥 未找到旋转蒸发仪设备! 😭")
+        raise ValueError(f"未找到旋转蒸发仪设备。请检查组态图中是否包含 class 包含 'rotavap'、'rotary' 或 'evaporat' 的设备")
+    
+    debug_print(f"🎉 成功找到旋转蒸发仪: {rotavap_device} ✨")
+    
+    # === 步骤2: 确定目标容器 ===
+    debug_print("📍 步骤2: 确定目标容器... 🥽")
+    
+    target_vessel = vessel
+    
+    # 如果vessel就是旋转蒸发仪设备，查找连接的容器
+    if vessel == rotavap_device:
+        debug_print("🔄 vessel就是旋转蒸发仪，查找连接的容器...")
+        connected_vessel = find_connected_vessel(G, rotavap_device)
+        if connected_vessel:
+            target_vessel = connected_vessel
+            debug_print(f"✅ 使用连接的容器: {target_vessel} 🥽✨")
+        else:
+            debug_print(f"⚠️ 未找到连接的容器，使用设备本身: {rotavap_device} 🔧")
+            target_vessel = rotavap_device
+    elif vessel in G.nodes() and G.nodes[vessel].get('type') == 'container':
+        debug_print(f"✅ 使用指定的容器: {vessel} 🥽✨")
+        target_vessel = vessel
+    else:
+        debug_print(f"⚠️ 容器 '{vessel}' 不存在或类型不正确，使用旋转蒸发仪设备: {rotavap_device} 🔧")
+        target_vessel = rotavap_device
+    
+    # === 🔧 新增：步骤3：单位解析处理 ===
+    debug_print("📍 步骤3: 单位解析处理... ⚡")
+    
+    # 解析时间
+    final_time = parse_time_input(time)
+    debug_print(f"🎯 时间解析完成: {time} → {final_time}s ({final_time/60:.1f}分钟) ⏰✨")
+    
+    # === 步骤4: 参数验证和修正 ===
+    debug_print("📍 步骤4: 参数验证和修正... 🔧")
+    
+    # 修正参数范围
+    if pressure <= 0 or pressure > 1.0:
+        debug_print(f"⚠️ 真空度 {pressure} bar 超出范围，修正为 0.1 bar 💨")
+        pressure = 0.1
+    else:
+        debug_print(f"✅ 真空度 {pressure} bar 在正常范围内 💨")
+    
+    if temp < 10.0 or temp > 200.0:
+        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 60°C 🌡️")
+        temp = 60.0
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内 🌡️")
+    
+    if final_time <= 0:
+        debug_print(f"⚠️ 时间 {final_time}s 无效，修正为 180s (3分钟) ⏰")
+        final_time = 180.0
+    else:
+        debug_print(f"✅ 时间 {final_time}s ({final_time/60:.1f}分钟) 有效 ⏰")
+    
+    if stir_speed < 10.0 or stir_speed > 300.0:
+        debug_print(f"⚠️ 旋转速度 {stir_speed} RPM 超出范围，修正为 100 RPM 🌪️")
+        stir_speed = 100.0
+    else:
+        debug_print(f"✅ 旋转速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
+    # 根据溶剂优化参数
+    if solvent:
+        debug_print(f"🧪 根据溶剂 '{solvent}' 优化参数... 🔬")
+        solvent_lower = solvent.lower()
+        
+        if any(s in solvent_lower for s in ['water', 'aqueous', 'h2o']):
+            temp = max(temp, 80.0)
+            pressure = max(pressure, 0.2)
+            debug_print("💧 水系溶剂：提高温度和真空度 🌡️💨")
+        elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+            temp = min(temp, 50.0)
+            pressure = min(pressure, 0.05)
+            debug_print("🍺 易挥发溶剂：降低温度和真空度 🌡️💨")
+        elif any(s in solvent_lower for s in ['dmso', 'dmi', 'toluene']):
+            temp = max(temp, 100.0)
+            pressure = min(pressure, 0.01)
+            debug_print("🔥 高沸点溶剂：提高温度，降低真空度 🌡️💨")
+        else:
+            debug_print("🧪 通用溶剂，使用标准参数 ✨")
+    else:
+        debug_print("🤷‍♀️ 未指定溶剂，使用默认参数 ✨")
+    
+    debug_print(f"🎯 最终参数: pressure={pressure} bar 💨, temp={temp}°C 🌡️, time={final_time}s ⏰, stir_speed={stir_speed} RPM 🌪️")
+    
+    # === 步骤5: 生成动作序列 ===
+    debug_print("📍 步骤5: 生成动作序列... 🎬")
+    
     action_sequence = []
     
-    print(f"EVAPORATE: 开始生成蒸发协议")
-    print(f"  - 源容器: {vessel}")
-    print(f"  - 真空度: {pressure} bar")
-    print(f"  - 温度: {temp}°C")
-    print(f"  - 时间: {time}s ({time/60:.1f}分钟)")
-    print(f"  - 旋转速度: {stir_speed} RPM")
-    
-    # 验证源容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"源容器 '{vessel}' 不存在于系统中")
-    
-    # 获取源容器中的液体体积
-    source_volume = get_vessel_liquid_volume(G, vessel)
-    print(f"EVAPORATE: 源容器 {vessel} 中有 {source_volume} mL 液体")
-    
-    # 查找旋转蒸发仪
-    try:
-        rotavap_id = find_rotavap_device(G)
-        print(f"EVAPORATE: 找到旋转蒸发仪: {rotavap_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到旋转蒸发仪: {str(e)}")
-    
-    # 查找旋转蒸发仪样品容器
-    rotavap_vessel = None
-    possible_rotavap_vessels = ["rotavap_flask", "rotavap", "flask_rotavap", "evaporation_flask"]
-    for rv in possible_rotavap_vessels:
-        if rv in G.nodes():
-            rotavap_vessel = rv
-            break
-    
-    if not rotavap_vessel:
-        raise ValueError(f"未找到旋转蒸发仪样品容器。尝试了: {possible_rotavap_vessels}")
-    
-    print(f"EVAPORATE: 找到旋转蒸发仪样品容器: {rotavap_vessel}")
-    
-    # 查找溶剂回收容器
-    try:
-        distillate_vessel = find_solvent_recovery_vessel(G)
-        print(f"EVAPORATE: 找到溶剂回收容器: {distillate_vessel}")
-    except ValueError as e:
-        print(f"EVAPORATE: 警告 - {str(e)}")
-        distillate_vessel = None
-    
-    # === 简化的体积计算策略 ===
-    if source_volume > 0:
-        # 如果能检测到液体体积，使用实际体积的大部分
-        transfer_volume = min(source_volume * 0.9, 250.0)  # 90%或最多250mL
-        print(f"EVAPORATE: 检测到液体体积，将转移 {transfer_volume} mL")
-    else:
-        # 如果检测不到液体体积，默认转移一整瓶 250mL
-        transfer_volume = 250.0
-        print(f"EVAPORATE: 未检测到液体体积，默认转移整瓶 {transfer_volume} mL")
-    
-    # === 第一步：将待蒸发溶液转移到旋转蒸发仪 ===
-    print(f"EVAPORATE: 将 {transfer_volume} mL 溶液从 {vessel} 转移到 {rotavap_vessel}")
-    try:
-        transfer_to_rotavap_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=vessel,
-            to_vessel=rotavap_vessel,
-            volume=transfer_volume,
-            flowrate=2.0,
-            transfer_flowrate=2.0
-        )
-        action_sequence.extend(transfer_to_rotavap_actions)
-    except Exception as e:
-        raise ValueError(f"无法将溶液转移到旋转蒸发仪: {str(e)}")
-    
-    # 转移后等待
-    wait_action = {
+    # 1. 等待稳定
+    debug_print("  🔄 动作1: 添加初始等待稳定... ⏳")
+    action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {"time": 10}
-    }
-    action_sequence.append(wait_action)
+    })
+    debug_print("  ✅ 初始等待动作已添加 ⏳✨")
+    
+    # 2. 执行蒸发
+    debug_print(f"  🌪️ 动作2: 执行蒸发操作...")
+    debug_print(f"    🔧 设备: {rotavap_device}")
+    debug_print(f"    🥽 容器: {target_vessel}")
+    debug_print(f"    💨 真空度: {pressure} bar")
+    debug_print(f"    🌡️ 温度: {temp}°C")
+    debug_print(f"    ⏰ 时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print(f"    🌪️ 旋转速度: {stir_speed} RPM")
     
-    # === 第二步：执行旋转蒸发 ===
-    print(f"EVAPORATE: 执行旋转蒸发操作")
     evaporate_action = {
-        "device_id": rotavap_id,
+        "device_id": rotavap_device,
         "action_name": "evaporate",
         "action_kwargs": {
-            "vessel": rotavap_vessel,
+            "vessel": target_vessel,
             "pressure": pressure,
             "temp": temp,
-            "time": time,
-            "stir_speed": stir_speed
+            "time": final_time,
+            "stir_speed": stir_speed,
+            "solvent": solvent
         }
     }
     action_sequence.append(evaporate_action)
+    debug_print("  ✅ 蒸发动作已添加 🌪️✨")
     
-    # 蒸发后等待系统稳定
-    wait_action = {
+    # 3. 蒸发后等待
+    debug_print("  🔄 动作3: 添加蒸发后等待... ⏳")
+    action_sequence.append({
         "action_name": "wait",
-        "action_kwargs": {"time": 30}
-    }
-    action_sequence.append(wait_action)
+        "action_kwargs": {"time": 10}
+    })
+    debug_print("  ✅ 蒸发后等待动作已添加 ⏳✨")
     
-    # === 第三步：溶剂回收（如果有回收容器）===
-    if distillate_vessel:
-        print(f"EVAPORATE: 回收冷凝溶剂到 {distillate_vessel}")
-        try:
-            condenser_vessel = "rotavap_condenser"
-            if condenser_vessel in G.nodes():
-                # 估算回收体积（约为转移体积的70% - 大部分溶剂被蒸发回收）
-                recovery_volume = transfer_volume * 0.7
-                print(f"EVAPORATE: 预计回收 {recovery_volume} mL 溶剂")
-                
-                recovery_actions = generate_pump_protocol(
-                    G=G,
-                    from_vessel=condenser_vessel,
-                    to_vessel=distillate_vessel,
-                    volume=recovery_volume,
-                    flowrate=3.0,
-                    transfer_flowrate=3.0
-                )
-                action_sequence.extend(recovery_actions)
-            else:
-                print("EVAPORATE: 未找到冷凝器容器，跳过溶剂回收")
-        except Exception as e:
-            print(f"EVAPORATE: 溶剂回收失败: {str(e)}")
-    
-    # === 第四步：将浓缩物转移回原容器 ===
-    print(f"EVAPORATE: 将浓缩物从旋转蒸发仪转移回 {vessel}")
-    try:
-        # 估算浓缩物体积（约为转移体积的20% - 大部分溶剂已蒸发）
-        concentrate_volume = transfer_volume * 0.2
-        print(f"EVAPORATE: 预计浓缩物体积 {concentrate_volume} mL")
-        
-        transfer_back_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=rotavap_vessel,
-            to_vessel=vessel,
-            volume=concentrate_volume,
-            flowrate=1.0,  # 浓缩物可能粘稠，用较慢流速
-            transfer_flowrate=1.0
-        )
-        action_sequence.extend(transfer_back_actions)
-    except Exception as e:
-        print(f"EVAPORATE: 将浓缩物转移回容器失败: {str(e)}")
-    
-    # === 第五步：清洗旋转蒸发仪 ===
-    print(f"EVAPORATE: 清洗旋转蒸发仪")
-    try:
-        # 查找清洗溶剂
-        cleaning_solvent = None
-        for solvent in ["flask_ethanol", "flask_acetone", "flask_water"]:
-            if solvent in G.nodes():
-                cleaning_solvent = solvent
-                break
-        
-        if cleaning_solvent and distillate_vessel:
-            # 用固定量溶剂清洗（不依赖检测体积）
-            cleaning_volume = 50.0  # 固定50mL清洗
-            print(f"EVAPORATE: 用 {cleaning_volume} mL {cleaning_solvent} 清洗")
-            
-            # 清洗溶剂加入
-            cleaning_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=cleaning_solvent,
-                to_vessel=rotavap_vessel,
-                volume=cleaning_volume,
-                flowrate=2.0,
-                transfer_flowrate=2.0
-            )
-            action_sequence.extend(cleaning_actions)
-            
-            # 将清洗液转移到废液/回收容器
-            waste_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=rotavap_vessel,
-                to_vessel=distillate_vessel,  # 使用回收容器作为废液
-                volume=cleaning_volume,
-                flowrate=2.0,
-                transfer_flowrate=2.0
-            )
-            action_sequence.extend(waste_actions)
-        
-    except Exception as e:
-        print(f"EVAPORATE: 清洗步骤失败: {str(e)}")
-    
-    print(f"EVAPORATE: 生成了 {len(action_sequence)} 个动作")
-    print(f"EVAPORATE: 蒸发协议生成完成")
-    print(f"EVAPORATE: 总处理体积: {transfer_volume} mL")
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 蒸发协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🌪️ 旋转蒸发仪: {rotavap_device} 🔧")
+    debug_print(f"🥽 目标容器: {target_vessel} 🧪")
+    debug_print(f"⚙️ 蒸发参数: {pressure} bar 💨, {temp}°C 🌡️, {final_time}s ⏰, {stir_speed} RPM 🌪️")
+    debug_print(f"⏱️ 预计总时间: {(final_time + 20)/60:.1f} 分钟 ⌛")
+    debug_print("🎊" * 20)
     
     return action_sequence
-
-
-# 便捷函数：常用蒸发方案 - 都使用250mL标准瓶体积
-def generate_quick_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 40.0,
-    time: float = 900.0  # 15分钟
-) -> List[Dict[str, Any]]:
-    """快速蒸发：低温、短时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.2, temp, time, 80.0)
-
-
-def generate_gentle_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 50.0,
-    time: float = 2700.0  # 45分钟
-) -> List[Dict[str, Any]]:
-    """温和蒸发：中等条件、较长时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.1, temp, time, 60.0)
-
-
-def generate_high_vacuum_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float = 35.0,
-    time: float = 3600.0  # 1小时
-) -> List[Dict[str, Any]]:
-    """高真空蒸发：低温、高真空、长时间、整瓶处理"""
-    return generate_evaporate_protocol(G, vessel, 0.01, temp, time, 120.0)
-
-
-def generate_standard_evaporate_protocol(
-    G: nx.DiGraph,
-    vessel: str
-) -> List[Dict[str, Any]]:
-    """标准蒸发：常用参数、整瓶250mL处理"""
-    return generate_evaporate_protocol(
-        G=G,
-        vessel=vessel, 
-        pressure=0.1,      # 标准真空度
-        temp=60.0,         # 适中温度
-        time=1800.0,       # 30分钟
-        stir_speed=100.0   # 适中旋转速度
-    )

unilabos/compile/filter_protocol.py

@@ -1,304 +1,236 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 import networkx as nx
-from .pump_protocol import generate_pump_protocol
+import logging
+from .pump_protocol import generate_pump_protocol_with_rinsing
 
+logger = logging.getLogger(__name__)
 
-def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
-    """获取容器中的液体体积"""
-    if vessel not in G.nodes():
-        return 0.0
-    
-    vessel_data = G.nodes[vessel].get('data', {})
-    liquids = vessel_data.get('liquid', [])
-    
-    total_volume = 0.0
-    for liquid in liquids:
-        if isinstance(liquid, dict) and 'liquid_volume' in liquid:
-            total_volume += liquid['liquid_volume']
-    
-    return total_volume
-
+def debug_print(message):
+    """调试输出"""
+    print(f"🧪 [FILTER] {message}", flush=True)
+    logger.info(f"[FILTER] {message}")
 
 def find_filter_device(G: nx.DiGraph) -> str:
     """查找过滤器设备"""
-    filter_nodes = [node for node in G.nodes() 
-                   if (G.nodes[node].get('class') or '') == 'virtual_filter']
+    debug_print("🔍 查找过滤器设备... 🌊")
     
-    if filter_nodes:
-        return filter_nodes[0]
+    # 查找过滤器设备
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'filter' in node_class.lower() or 'filter' in node.lower():
+            debug_print(f"🎉 找到过滤器设备: {node} ✨")
+            return node
     
-    raise ValueError("系统中未找到过滤器设备")
+    # 如果没找到，寻找可能的过滤器名称
+    debug_print("🔎 在预定义名称中搜索过滤器... 📋")
+    possible_names = ["filter", "filter_1", "virtual_filter", "filtration_unit"]
+    for name in possible_names:
+        if name in G.nodes():
+            debug_print(f"🎉 找到过滤器设备: {name} ✨")
+            return name
+    
+    debug_print("😭 未找到过滤器设备 💔")
+    raise ValueError("未找到过滤器设备")
 
-
-def find_filter_vessel(G: nx.DiGraph) -> str:
-    """查找过滤器专用容器"""
-    possible_names = [
-        "filter_vessel",        # 标准过滤器容器
-        "filtration_vessel",    # 备选名称
-        "vessel_filter",        # 备选名称
-        "filter_unit",          # 备选名称
-        "filter"               # 简单名称
-    ]
+def validate_vessel(G: nx.DiGraph, vessel: str, vessel_type: str = "容器") -> None:
+    """验证容器是否存在"""
+    debug_print(f"🔍 验证{vessel_type}: '{vessel}' 🧪")
     
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
+    if not vessel:
+        debug_print(f"❌ {vessel_type}不能为空! 😱")
+        raise ValueError(f"{vessel_type}不能为空")
     
-    raise ValueError(f"未找到过滤器容器。尝试了以下名称: {possible_names}")
-
-
-def find_filtrate_vessel(G: nx.DiGraph, filtrate_vessel: str = "") -> str:
-    """查找滤液收集容器"""
-    if filtrate_vessel and filtrate_vessel in G.nodes():
-        return filtrate_vessel
+    if vessel not in G.nodes():
+        debug_print(f"❌ {vessel_type} '{vessel}' 不存在于系统中! 😞")
+        raise ValueError(f"{vessel_type} '{vessel}' 不存在于系统中")
     
-    # 自动查找滤液容器
-    possible_names = [
-        "filtrate_vessel",
-        "collection_bottle_1",
-        "collection_bottle_2",
-        "waste_workup"
-    ]
-    
-    for vessel_name in possible_names:
-        if vessel_name in G.nodes():
-            return vessel_name
-    
-    raise ValueError(f"未找到滤液收集容器。尝试了以下名称: {possible_names}")
-
-
-def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
-    """查找与指定容器相连的加热搅拌器"""
-    # 查找所有加热搅拌器节点
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
-    
-    # 检查哪个加热器与目标容器相连
-    for heatchill in heatchill_nodes:
-        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
-            return heatchill
-    
-    # 如果没有直接连接，返回第一个可用的加热器
-    if heatchill_nodes:
-        return heatchill_nodes[0]
-    
-    raise ValueError(f"未找到与容器 {vessel} 相连的加热搅拌器")
-
+    debug_print(f"✅ {vessel_type} '{vessel}' 验证通过 🎯")
 
 def generate_filter_protocol(
     G: nx.DiGraph,
     vessel: str,
     filtrate_vessel: str = "",
-    stir: bool = False,
-    stir_speed: float = 300.0,
-    temp: float = 25.0,
-    continue_heatchill: bool = False,
-    volume: float = 0.0
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成过滤操作的协议序列，复用 pump_protocol 的成熟算法
-    
-    过滤流程：
-    1. 液体转移：将待过滤溶液从源容器转移到过滤器
-    2. 启动加热搅拌：设置温度和搅拌
-    3. 执行过滤：通过过滤器分离固液
-    4. (可选) 继续或停止加热搅拌
+    生成过滤操作的协议序列
     
     Args:
-        G: 有向图，节点为设备和容器，边为流体管道
-        vessel: 包含待过滤溶液的容器名称
-        filtrate_vessel: 滤液收集容器（可选，自动查找）
-        stir: 是否在过滤过程中搅拌
-        stir_speed: 搅拌速度 (RPM)
-        temp: 过滤温度 (°C)
-        continue_heatchill: 过滤后是否继续加热搅拌
-        volume: 预期过滤体积 (mL)，0表示全部过滤
+        G: 设备图
+        vessel: 过滤容器名称（必需）- 包含需要过滤的混合物
+        filtrate_vessel: 滤液容器名称（可选）- 如果提供则收集滤液
+        **kwargs: 其他参数（兼容性）
     
     Returns:
         List[Dict[str, Any]]: 过滤操作的动作序列
     """
+    
+    debug_print("🌊" * 20)
+    debug_print("🚀 开始生成过滤协议 ✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel}")
+    debug_print(f"  🧪 filtrate_vessel: {filtrate_vessel}")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("🌊" * 20)
+    
     action_sequence = []
     
-    print(f"FILTER: 开始生成过滤协议")
-    print(f"  - 源容器: {vessel}")
-    print(f"  - 滤液容器: {filtrate_vessel}")
-    print(f"  - 搅拌: {stir} ({stir_speed} RPM)" if stir else "  - 搅拌: 否")
-    print(f"  - 过滤温度: {temp}°C")
-    print(f"  - 预期过滤体积: {volume} mL" if volume > 0 else "  - 预期过滤体积: 全部")
-    print(f"  - 继续加热搅拌: {continue_heatchill}")
+    # === 参数验证 ===
+    debug_print("📍 步骤1: 参数验证... 🔧")
     
-    # 验证源容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"源容器 '{vessel}' 不存在于系统中")
+    # 验证必需参数
+    debug_print("  🔍 验证必需参数...")
+    validate_vessel(G, vessel, "过滤容器")
+    debug_print("  ✅ 必需参数验证完成 🎯")
     
-    # 获取源容器中的液体体积
-    source_volume = get_vessel_liquid_volume(G, vessel)
-    print(f"FILTER: 源容器 {vessel} 中有 {source_volume} mL 液体")
-    
-    # 查找过滤器设备
-    try:
-        filter_id = find_filter_device(G)
-        print(f"FILTER: 找到过滤器: {filter_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到过滤器: {str(e)}")
-    
-    # 查找过滤器容器
-    try:
-        filter_vessel_id = find_filter_vessel(G)
-        print(f"FILTER: 找到过滤器容器: {filter_vessel_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到过滤器容器: {str(e)}")
-    
-    # 查找滤液收集容器
-    try:
-        actual_filtrate_vessel = find_filtrate_vessel(G, filtrate_vessel)
-        print(f"FILTER: 找到滤液收集容器: {actual_filtrate_vessel}")
-    except ValueError as e:
-        raise ValueError(f"无法找到滤液收集容器: {str(e)}")
-    
-    # 查找加热搅拌器（如果需要温度控制或搅拌）
-    heatchill_id = None
-    if temp != 25.0 or stir or continue_heatchill:
-        try:
-            heatchill_id = find_connected_heatchill(G, filter_vessel_id)
-            print(f"FILTER: 找到加热搅拌器: {heatchill_id}")
-        except ValueError as e:
-            print(f"FILTER: 警告 - {str(e)}")
-    
-    # === 简化的体积计算策略 ===
-    if volume > 0:
-        transfer_volume = min(volume, source_volume if source_volume > 0 else volume)
-        print(f"FILTER: 指定过滤体积 {transfer_volume} mL")
-    elif source_volume > 0:
-        transfer_volume = source_volume * 0.9  # 90%
-        print(f"FILTER: 检测到液体体积，将过滤 {transfer_volume} mL")
+    # 验证可选参数
+    debug_print("  🔍 验证可选参数...")
+    if filtrate_vessel:
+        validate_vessel(G, filtrate_vessel, "滤液容器")
+        debug_print("  🌊 模式: 过滤并收集滤液 💧")
     else:
-        transfer_volume = 50.0  # 默认过滤量
-        print(f"FILTER: 未检测到液体体积，默认过滤 {transfer_volume} mL")
+        debug_print("  🧱 模式: 过滤并收集固体 🔬")
+    debug_print("  ✅ 可选参数验证完成 🎯")
     
-    # === 第一步：启动加热搅拌器（在转移前预热） ===
-    if heatchill_id and (temp != 25.0 or stir):
-        print(f"FILTER: 启动加热搅拌器，温度: {temp}°C，搅拌: {stir}")
-        
-        heatchill_action = {
-            "device_id": heatchill_id,
-            "action_name": "heat_chill_start",
-            "action_kwargs": {
-                "vessel": filter_vessel_id,
-                "temp": temp,
-                "purpose": f"过滤过程温度控制和搅拌"
-            }
-        }
-        action_sequence.append(heatchill_action)
-        
-        # 等待温度稳定
-        if temp != 25.0:
-            wait_time = min(30, abs(temp - 25.0) * 1.0)  # 根据温差估算预热时间
-            action_sequence.append({
-                "action_name": "wait",
-                "action_kwargs": {"time": wait_time}
-            })
+    # === 查找设备 ===
+    debug_print("📍 步骤2: 查找设备... 🔍")
     
-    # === 第二步：将待过滤溶液转移到过滤器 ===
-    print(f"FILTER: 将 {transfer_volume} mL 溶液从 {vessel} 转移到 {filter_vessel_id}")
     try:
-        # 使用成熟的 pump_protocol 算法进行液体转移
-        transfer_to_filter_actions = generate_pump_protocol(
-            G=G,
-            from_vessel=vessel,
-            to_vessel=filter_vessel_id,
-            volume=transfer_volume,
-            flowrate=1.0,  # 过滤转移用较慢速度，避免扰动
-            transfer_flowrate=1.5
-        )
-        action_sequence.extend(transfer_to_filter_actions)
+        debug_print("  🔎 搜索过滤器设备...")
+        filter_device = find_filter_device(G)
+        debug_print(f"  🎉 使用过滤器设备: {filter_device} 🌊✨")
+        
     except Exception as e:
-        raise ValueError(f"无法将溶液转移到过滤器: {str(e)}")
+        debug_print(f"  ❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"设备查找失败: {str(e)}")
     
-    # 转移后等待
-    action_sequence.append({
-        "action_name": "wait",
-        "action_kwargs": {"time": 5}
-    })
+    # === 转移到过滤器（如果需要）===
+    debug_print("📍 步骤3: 转移到过滤器... 🚚")
     
-    # === 第三步：执行过滤操作（完全按照 Filter.action 参数） ===
-    print(f"FILTER: 执行过滤操作")
+    if vessel != filter_device:
+        debug_print(f"  🚛 需要转移: {vessel} → {filter_device} 📦")
+        
+        try:
+            debug_print("  🔄 开始执行转移操作...")
+            # 使用pump protocol转移液体到过滤器
+            transfer_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=vessel,
+                to_vessel=filter_device,
+                volume=0.0,  # 转移所有液体
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            
+            if transfer_actions:
+                action_sequence.extend(transfer_actions)
+                debug_print(f"  ✅ 添加了 {len(transfer_actions)} 个转移动作 🚚✨")
+            else:
+                debug_print("  ⚠️ 转移协议返回空序列 🤔")
+                
+        except Exception as e:
+            debug_print(f"  ❌ 转移失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能是直接连接的过滤器 🤞")
+    else:
+        debug_print("  ✅ 过滤容器就是过滤器，无需转移 🎯")
+    
+    # === 执行过滤操作 ===
+    debug_print("📍 步骤4: 执行过滤操作... 🌊")
+    
+    # 构建过滤动作参数
+    debug_print("  ⚙️ 构建过滤参数...")
+    filter_kwargs = {
+        "vessel": filter_device,  # 过滤器设备
+        "filtrate_vessel": filtrate_vessel,  # 滤液容器（可能为空）
+        "stir": kwargs.get("stir", False),
+        "stir_speed": kwargs.get("stir_speed", 0.0),
+        "temp": kwargs.get("temp", 25.0),
+        "continue_heatchill": kwargs.get("continue_heatchill", False),
+        "volume": kwargs.get("volume", 0.0)  # 0表示过滤所有
+    }
+    
+    debug_print(f"  📋 过滤参数: {filter_kwargs}")
+    debug_print("  🌊 开始过滤操作...")
+    
+    # 过滤动作
     filter_action = {
-        "device_id": filter_id,
+        "device_id": filter_device,
         "action_name": "filter",
-        "action_kwargs": {
-            "vessel": filter_vessel_id,
-            "filtrate_vessel": actual_filtrate_vessel,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "temp": temp,
-            "continue_heatchill": continue_heatchill,
-            "volume": transfer_volume
-        }
+        "action_kwargs": filter_kwargs
     }
     action_sequence.append(filter_action)
+    debug_print("  ✅ 过滤动作已添加 🌊✨")
     
     # 过滤后等待
+    debug_print("  ⏳ 添加过滤后等待...")
     action_sequence.append({
         "action_name": "wait",
-        "action_kwargs": {"time": 10}
+        "action_kwargs": {"time": 10.0}
     })
+    debug_print("  ✅ 过滤后等待动作已添加 ⏰✨")
     
-    # === 第四步：如果不继续加热搅拌，停止加热器 ===
-    if heatchill_id and not continue_heatchill and (temp != 25.0 or stir):
-        print(f"FILTER: 停止加热搅拌器")
+    # === 收集滤液（如果需要）===
+    debug_print("📍 步骤5: 收集滤液... 💧")
+    
+    if filtrate_vessel:
+        debug_print(f"  🧪 收集滤液: {filter_device} → {filtrate_vessel} 💧")
         
-        stop_action = {
-            "device_id": heatchill_id,
-            "action_name": "heat_chill_stop",
-            "action_kwargs": {
-                "vessel": filter_vessel_id
-            }
-        }
-        action_sequence.append(stop_action)
+        try:
+            debug_print("  🔄 开始执行收集操作...")
+            # 使用pump protocol收集滤液
+            collect_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=filter_device,
+                to_vessel=filtrate_vessel,
+                volume=0.0,  # 收集所有滤液
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            
+            if collect_actions:
+                action_sequence.extend(collect_actions)
+                debug_print(f"  ✅ 添加了 {len(collect_actions)} 个收集动作 🧪✨")
+            else:
+                debug_print("  ⚠️ 收集协议返回空序列 🤔")
+                
+        except Exception as e:
+            debug_print(f"  ❌ 收集滤液失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能滤液直接流入指定容器 🤞")
+    else:
+        debug_print("  🧱 未指定滤液容器，固体保留在过滤器中 🔬")
     
-    print(f"FILTER: 生成了 {len(action_sequence)} 个动作")
-    print(f"FILTER: 过滤协议生成完成")
+    # === 最终等待 ===
+    debug_print("📍 步骤6: 最终等待... ⏰")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {"time": 5.0}
+    })
+    debug_print("  ✅ 最终等待动作已添加 ⏰✨")
+    
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 过滤协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🥽 过滤容器: {vessel} 🧪")
+    debug_print(f"🌊 过滤器设备: {filter_device} 🔧")
+    debug_print(f"💧 滤液容器: {filtrate_vessel or '无（保留固体）'} 🧱")
+    debug_print(f"⏱️ 预计总时间: {(len(action_sequence) * 5):.0f} 秒 ⌛")
+    debug_print("🎊" * 20)
     
     return action_sequence
-
-
-# 便捷函数：常用过滤方案
-def generate_gravity_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = ""
-) -> List[Dict[str, Any]]:
-    """重力过滤：室温，无搅拌"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, False, 0.0, 25.0, False, 0.0)
-
-
-def generate_hot_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    temp: float = 60.0
-) -> List[Dict[str, Any]]:
-    """热过滤：高温过滤，防止结晶析出"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, False, 0.0, temp, False, 0.0)
-
-
-def generate_stirred_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    stir_speed: float = 200.0
-) -> List[Dict[str, Any]]:
-    """搅拌过滤：低速搅拌，防止滤饼堵塞"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, True, stir_speed, 25.0, False, 0.0)
-
-
-def generate_hot_stirred_filter_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    temp: float = 60.0,
-    stir_speed: float = 300.0
-) -> List[Dict[str, Any]]:
-    """热搅拌过滤：高温搅拌过滤"""
-    return generate_filter_protocol(G, vessel, filtrate_vessel, True, stir_speed, temp, False, 0.0)

unilabos/compile/heatchill_protocol.py

@@ -1,373 +1,376 @@
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🌡️ [HEATCHILL] {message}", flush=True)
+    logger.info(f"[HEATCHILL] {message}")
+
+def parse_time_input(time_input: Union[str, float, int]) -> float:
+    """
+    解析时间输入（统一函数）
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 300.0
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间: '{time_str}'")
+    
+    # ❓ 特殊值处理
+    special_times = {
+        '?': 300.0, 'unknown': 300.0, 'tbd': 300.0,
+        'overnight': 43200.0, 'several hours': 10800.0, 
+        'few hours': 7200.0, 'long time': 3600.0, 'short time': 300.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s ({result/60:.1f}分钟)")
+        return result
+    
+    # 🔢 纯数字处理
+    try:
+        result = float(time_str)
+        debug_print(f"⏰ 纯数字: {time_str} → {result}s")
+        return result
+    except ValueError:
+        pass
+    
+    # 📐 正则表达式解析
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 300s")
+        return 300.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 's'
+    
+    # 📏 单位转换
+    unit_multipliers = {
+        's': 1.0, 'sec': 1.0, 'second': 1.0, 'seconds': 1.0,
+        'm': 60.0, 'min': 60.0, 'mins': 60.0, 'minute': 60.0, 'minutes': 60.0,
+        'h': 3600.0, 'hr': 3600.0, 'hrs': 3600.0, 'hour': 3600.0, 'hours': 3600.0,
+        'd': 86400.0, 'day': 86400.0, 'days': 86400.0
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"✅ 时间解析: '{time_str}' → {value} {unit} → {result}s ({result/60:.1f}分钟)")
+    return result
+
+def parse_temp_input(temp_input: Union[str, float], default_temp: float = 25.0) -> float:
+    """
+    解析温度输入（统一函数）
+    
+    Args:
+        temp_input: 温度输入
+        default_temp: 默认温度
+        
+    Returns:
+        float: 温度（°C）
+    """
+    if not temp_input:
+        return default_temp
+    
+    # 🔢 数值输入
+    if isinstance(temp_input, (int, float)):
+        result = float(temp_input)
+        debug_print(f"🌡️ 数值温度: {temp_input} → {result}°C")
+        return result
+    
+    # 📝 字符串输入
+    temp_str = str(temp_input).lower().strip()
+    debug_print(f"🔍 解析温度: '{temp_str}'")
+    
+    # 🎯 特殊温度
+    special_temps = {
+        "room temperature": 25.0, "reflux": 78.0, "ice bath": 0.0,
+        "boiling": 100.0, "hot": 60.0, "warm": 40.0, "cold": 10.0
+    }
+    
+    if temp_str in special_temps:
+        result = special_temps[temp_str]
+        debug_print(f"🎯 特殊温度: '{temp_str}' → {result}°C")
+        return result
+    
+    # 📐 正则解析（如 "256 °C"）
+    temp_pattern = r'(\d+(?:\.\d+)?)\s*°?[cf]?'
+    match = re.search(temp_pattern, temp_str)
+    
+    if match:
+        result = float(match.group(1))
+        debug_print(f"✅ 温度解析: '{temp_str}' → {result}°C")
+        return result
+    
+    debug_print(f"⚠️ 无法解析温度: '{temp_str}'，使用默认值: {default_temp}°C")
+    return default_temp
 
 def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
-    """
-    查找与指定容器相连的加热/冷却设备
-    """
-    # 查找所有加热/冷却设备节点
-    heatchill_nodes = [node for node in G.nodes() 
-                      if (G.nodes[node].get('class') or '') == 'virtual_heatchill']
+    """查找与指定容器相连的加热/冷却设备"""
+    debug_print(f"🔍 查找加热设备，目标容器: {vessel}")
     
-    # 检查哪个加热/冷却设备与目标容器相连（机械连接）
-    for heatchill in heatchill_nodes:
-        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
-            return heatchill
+    # 🔧 查找所有加热设备
+    heatchill_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'heatchill' in node_class.lower() or 'virtual_heatchill' in node_class:
+            heatchill_nodes.append(node)
+            debug_print(f"🎉 找到加热设备: {node}")
     
-    # 如果没有直接连接，返回第一个可用的加热/冷却设备
+    # 🔗 检查连接
+    if vessel and heatchill_nodes:
+        for heatchill in heatchill_nodes:
+            if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+                debug_print(f"✅ 加热设备 '{heatchill}' 与容器 '{vessel}' 相连")
+                return heatchill
+    
+    # 🎯 使用第一个可用设备
     if heatchill_nodes:
-        return heatchill_nodes[0]
+        selected = heatchill_nodes[0]
+        debug_print(f"🔧 使用第一个加热设备: {selected}")
+        return selected
     
-    raise ValueError("系统中未找到可用的加热/冷却设备")
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到加热设备，使用默认设备")
+    return "heatchill_1"
 
+def validate_and_fix_params(temp: float, time: float, stir_speed: float) -> tuple:
+    """验证和修正参数"""
+    # 🌡️ 温度范围验证
+    if temp < -50.0 or temp > 300.0:
+        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 25°C")
+        temp = 25.0
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内")
+    
+    # ⏰ 时间验证
+    if time < 0:
+        debug_print(f"⚠️ 时间 {time}s 无效，修正为 300s")
+        time = 300.0
+    else:
+        debug_print(f"✅ 时间 {time}s ({time/60:.1f}分钟) 有效")
+    
+    # 🌪️ 搅拌速度验证
+    if stir_speed < 0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM")
+        stir_speed = 300.0
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内")
+    
+    return temp, time, stir_speed
 
 def generate_heat_chill_protocol(
     G: nx.DiGraph,
     vessel: str,
-    temp: float,
-    time: float,
+    temp: float = 25.0,
+    time: Union[str, float] = "300",
+    temp_spec: str = "",
+    time_spec: str = "",
+    pressure: str = "",
+    reflux_solvent: str = "",
     stir: bool = False,
     stir_speed: float = 300.0,
-    purpose: str = "加热/冷却操作"
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成加热/冷却操作的协议序列 - 带时间限制的完整操作
+    生成加热/冷却操作的协议序列
     """
-    action_sequence = []
     
-    print(f"HEATCHILL: 开始生成加热/冷却协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 持续时间: {time}秒")
-    print(f"  - 使用内置搅拌: {stir}, 速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
+    debug_print("🌡️" * 20)
+    debug_print("🚀 开始生成加热冷却协议 ✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel}")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🎯 temp_spec: {temp_spec}")
+    debug_print(f"  ⏱️ time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir: {stir} ({stir_speed} RPM)")
+    debug_print("🌡️" * 20)
+    
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel:
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
     
-    # 1. 验证容器存在
     if vessel not in G.nodes():
+        debug_print(f"❌ 容器 '{vessel}' 不存在于系统中! 😞")
         raise ValueError(f"容器 '{vessel}' 不存在于系统中")
     
-    # 2. 查找加热/冷却设备
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    #温度解析：优先使用 temp_spec
+    final_temp = parse_temp_input(temp_spec, temp) if temp_spec else temp
+    
+    # 时间解析：优先使用 time_spec
+    final_time = parse_time_input(time_spec) if time_spec else parse_time_input(time)
+    
+    # 参数修正
+    final_temp, final_time, stir_speed = validate_and_fix_params(final_temp, final_time, stir_speed)
+    
+    debug_print(f"🎯 最终参数: temp={final_temp}°C, time={final_time}s, stir_speed={stir_speed} RPM")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找加热设备... 🔍")
     try:
         heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
+        debug_print(f"🎉 使用加热设备: {heatchill_id} ✨")
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"无法找到加热设备: {str(e)}")
     
-    # 3. 执行加热/冷却操作
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成加热动作... 🔥")
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_time = final_time
+    simulation_time_limit = 100.0  # 模拟运行时间限制：100秒
+    
+    if final_time > simulation_time_limit:
+        final_time = simulation_time_limit
+        debug_print(f"  🎮 模拟运行优化: {original_time}s → {final_time}s (限制为{simulation_time_limit}s) ⚡")
+        debug_print(f"  📊 时间缩短: {original_time/60:.1f}分钟 → {final_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_time}s ({final_time/60:.1f}分钟) 保持不变 🎯")
+    
+    action_sequence = []
     heatchill_action = {
         "device_id": heatchill_id,
         "action_name": "heat_chill",
         "action_kwargs": {
             "vessel": vessel,
-            "temp": temp,
-            "time": time,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "status": "start"
+            "temp": float(final_temp),
+            "time": float(final_time),
+            "stir": bool(stir),
+            "stir_speed": float(stir_speed),
+            "purpose": str(purpose or f"加热到 {final_temp}°C") + (f" (模拟时间: {final_time}s)" if original_time != final_time else "")
         }
     }
-    
     action_sequence.append(heatchill_action)
+    debug_print("✅ 加热动作已添加 🔥✨")
+    
+    # 显示时间调整信息
+    if original_time != final_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_time/60:.1f}分钟，实际模拟 {final_time/60:.1f}分钟 ⚡")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 加热冷却协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 加热容器: {vessel}")
+    debug_print(f"🌡️ 目标温度: {final_temp}°C")
+    debug_print(f"⏰ 加热时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print("🎊" * 20)
     
-    print(f"HEATCHILL: 生成了 {len(action_sequence)} 个动作")
     return action_sequence
 
+def generate_heat_chill_to_temp_protocol(
+    G: nx.DiGraph,
+    vessel: str,
+    temp: float = 25.0,
+    time: Union[str, float] = 100.0,
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """生成加热到指定温度的协议（简化版）"""
+    debug_print(f"🌡️ 生成加热到温度协议: {vessel} → {temp}°C")
+    return generate_heat_chill_protocol(G, vessel, temp, time, **kwargs)
 
 def generate_heat_chill_start_protocol(
     G: nx.DiGraph,
     vessel: str,
-    temp: float,
-    purpose: str = "开始加热/冷却"
+    temp: float = 25.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成开始加热/冷却操作的协议序列
-    """
-    action_sequence = []
+    """生成开始加热操作的协议序列"""
     
-    print(f"HEATCHILL_START: 开始生成加热/冷却启动协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 目的: {purpose}")
+    debug_print("🔥 开始生成启动加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel}, 🌡️ temp: {temp}°C")
     
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 基础验证
+    if not vessel or vessel not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_START: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
+    # 查找设备
+    heatchill_id = find_connected_heatchill(G, vessel)
     
-    # 3. 执行开始加热/冷却操作
-    heatchill_start_action = {
+    # 生成动作
+    action_sequence = [{
         "device_id": heatchill_id,
         "action_name": "heat_chill_start",
         "action_kwargs": {
             "vessel": vessel,
             "temp": temp,
-            "purpose": purpose
+            "purpose": purpose or f"开始加热到 {temp}°C"
         }
-    }
+    }]
     
-    action_sequence.append(heatchill_start_action)
-    
-    print(f"HEATCHILL_START: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 启动加热协议生成完成 🎯")
     return action_sequence
 
-
 def generate_heat_chill_stop_protocol(
     G: nx.DiGraph,
-    vessel: str
+    vessel: str,
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成停止加热/冷却操作的协议序列
-    """
-    action_sequence = []
+    """生成停止加热操作的协议序列"""
     
-    print(f"HEATCHILL_STOP: 开始生成加热/冷却停止协议")
-    print(f"  - 容器: {vessel}")
+    debug_print("🛑 开始生成停止加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel}")
     
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 基础验证
+    if not vessel or vessel not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_STOP: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
+    # 查找设备
+    heatchill_id = find_connected_heatchill(G, vessel)
     
-    # 3. 执行停止加热/冷却操作
-    heatchill_stop_action = {
+    # 生成动作
+    action_sequence = [{
         "device_id": heatchill_id,
         "action_name": "heat_chill_stop",
         "action_kwargs": {
             "vessel": vessel
         }
-    }
+    }]
     
-    action_sequence.append(heatchill_stop_action)
-    
-    print(f"HEATCHILL_STOP: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 停止加热协议生成完成 🎯")
     return action_sequence
 
-
-def generate_heat_chill_to_temp_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    active: bool = True,
-    continue_heatchill: bool = False,
-    stir: bool = False,
-    stir_speed: Optional[float] = None,
-    purpose: Optional[str] = None
-) -> List[Dict[str, Any]]:
-    """
-    生成加热/冷却到指定温度的协议序列 - 智能温控协议
-    
-    **关键修复**: 学习 pump_protocol 的模式，直接使用设备基础动作，不依赖特定的 Action 文件
-    """
-    action_sequence = []
-    
-    # 设置默认值
-    if stir_speed is None:
-        stir_speed = 300.0
-    if purpose is None:
-        purpose = f"智能温控到 {temp}°C"
-    
-    print(f"HEATCHILL_TO_TEMP: 开始生成智能温控协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 目标温度: {temp}°C")
-    print(f"  - 主动控温: {active}")
-    print(f"  - 达到温度后继续: {continue_heatchill}")
-    print(f"  - 搅拌: {stir}, 速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
-    
-    # 1. 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
-    
-    # 2. 查找加热/冷却设备
-    try:
-        heatchill_id = find_connected_heatchill(G, vessel)
-        print(f"HEATCHILL_TO_TEMP: 找到加热/冷却设备: {heatchill_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到加热/冷却设备: {str(e)}")
-    
-    # 3. 根据参数选择合适的基础动作组合 (学习 pump_protocol 的模式)
-    if not active:
-        print(f"HEATCHILL_TO_TEMP: 非主动模式，仅等待")
-        action_sequence.append({
-            "action_name": "wait",
-            "action_kwargs": {
-                "time": 10.0,
-                "purpose": f"等待容器 {vessel} 自然达到 {temp}°C"
-            }
-        })
-    else:
-        if continue_heatchill:
-            # 持续模式：使用 heat_chill_start 基础动作
-            print(f"HEATCHILL_TO_TEMP: 使用持续温控模式")
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_start",  # ← 直接使用设备基础动作
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "temp": temp,
-                    "purpose": f"{purpose} (持续保温)"
-                }
-            })
-        else:
-            # 一次性模式：使用 heat_chill 基础动作
-            print(f"HEATCHILL_TO_TEMP: 使用一次性温控模式")
-            estimated_time = max(60.0, min(900.0, abs(temp - 25.0) * 30.0))
-            print(f"HEATCHILL_TO_TEMP: 估算所需时间: {estimated_time}秒")
-            
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill",  # ← 直接使用设备基础动作
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "temp": temp,
-                    "time": estimated_time,
-                    "stir": stir,
-                    "stir_speed": stir_speed,
-                    "status": "start"
-                }
-            })
-    
-    print(f"HEATCHILL_TO_TEMP: 生成了 {len(action_sequence)} 个动作")
-    return action_sequence
-
-
-# 扩展版本的加热/冷却协议，集成智能温控功能
-def generate_smart_heat_chill_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 0.0,  # 0表示自动估算
-    active: bool = True,
-    continue_heatchill: bool = False,
-    stir: bool = False,
-    stir_speed: float = 300.0,
-    purpose: str = "智能加热/冷却"
-) -> List[Dict[str, Any]]:
-    """
-    这个函数集成了 generate_heat_chill_to_temp_protocol 的智能逻辑，
-    但使用现有的 Action 类型
-    """
-    # 如果时间为0，自动估算
-    if time == 0.0:
-        estimated_time = max(60.0, min(900.0, abs(temp - 25.0) * 30.0))
-        time = estimated_time
-    
-    if continue_heatchill:
-        # 使用持续模式
-        return generate_heat_chill_start_protocol(G, vessel, temp, purpose)
-    else:
-        # 使用定时模式
-        return generate_heat_chill_protocol(G, vessel, temp, time, stir, stir_speed, purpose)
-
-
-# 便捷函数
-def generate_heating_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 300.0,
-    stir: bool = True,
-    stir_speed: float = 300.0
-) -> List[Dict[str, Any]]:
-    """生成加热协议的便捷函数"""
-    return generate_heat_chill_protocol(
-        G=G, vessel=vessel, temp=temp, time=time, 
-        stir=stir, stir_speed=stir_speed, purpose=f"加热到 {temp}°C"
-    )
-
-
-def generate_cooling_protocol(
-    G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float = 600.0,
-    stir: bool = True,
-    stir_speed: float = 200.0
-) -> List[Dict[str, Any]]:
-    """生成冷却协议的便捷函数"""
-    return generate_heat_chill_protocol(
-        G=G, vessel=vessel, temp=temp, time=time,
-        stir=stir, stir_speed=stir_speed, purpose=f"冷却到 {temp}°C"
-    )
-
-
-# # 温度预设快捷函数
-# def generate_room_temp_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     stir: bool = False
-# ) -> List[Dict[str, Any]]:
-#     """返回室温的快捷函数"""
-#     return generate_heat_chill_to_temp_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=25.0,
-#         active=True,
-#         continue_heatchill=False,
-#         stir=stir,
-#         purpose="冷却到室温"
-#     )
-
-
-# def generate_reflux_heating_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     temp: float,
-#     time: float = 3600.0  # 1小时回流
-# ) -> List[Dict[str, Any]]:
-#     """回流加热的快捷函数"""
-#     return generate_heat_chill_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=temp,
-#         time=time,
-#         stir=True,
-#         stir_speed=400.0,  # 回流时较快搅拌
-#         purpose=f"回流加热到 {temp}°C"
-#     )
-
-
-# def generate_ice_bath_protocol(
-#     G: nx.DiGraph,
-#     vessel: str,
-#     time: float = 600.0  # 10分钟冰浴
-# ) -> List[Dict[str, Any]]:
-#     """冰浴冷却的快捷函数"""
-#     return generate_heat_chill_protocol(
-#         G=G,
-#         vessel=vessel,
-#         temp=0.0,
-#         time=time,
-#         stir=True,
-#         stir_speed=150.0,  # 冰浴时缓慢搅拌
-#         purpose="冰浴冷却到 0°C"
-#     )
-
-
 # 测试函数
 def test_heatchill_protocol():
-    """测试加热/冷却协议的示例"""
-    print("=== HEAT CHILL PROTOCOL 测试 ===")
-    print("完整的四个协议函数：")
-    print("1. generate_heat_chill_protocol - 带时间限制的完整操作")
-    print("2. generate_heat_chill_start_protocol - 持续加热/冷却")
-    print("3. generate_heat_chill_stop_protocol - 停止加热/冷却")
-    print("4. generate_heat_chill_to_temp_protocol - 智能温控 (您的 HeatChillToTemp)")
-    print("测试完成")
-
+    """测试加热协议"""
+    debug_print("🧪 === HEATCHILL PROTOCOL 测试 === ✨")
+    debug_print("✅ 测试完成 🎉")
 
 if __name__ == "__main__":
     test_heatchill_protocol()

unilabos/compile/hydrogenate_protocol.py

@@ -255,11 +255,23 @@ def generate_hydrogenate_protocol(
         action_sequence.append({
             "action_name": "wait",
             "action_kwargs": {
-                "time": 120.0,
+                "time": 20.0,
                 "description": f"等待温度稳定到 {temperature}°C"
             }
         })
         
+        # 🕐 模拟运行时间优化
+        print("HYDROGENATE: 检查模拟运行时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            print(f"HYDROGENATE: 模拟运行优化: {original_reaction_time}s → {reaction_time}s (限制为{simulation_time_limit}s)")
+            print(f"HYDROGENATE: 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"HYDROGENATE: 时间在限制内: {reaction_time}s ({reaction_time/60:.1f}分钟) 保持不变")
+        
         # 保持反应温度
         action_sequence.append({
             "device_id": heater_id,
@@ -268,19 +280,41 @@ def generate_hydrogenate_protocol(
                 "vessel": vessel,
                 "temp": temperature,
                 "time": reaction_time,
-                "purpose": f"氢化反应: 保持 {temperature}°C，反应 {reaction_time/3600:.1f} 小时"
+                "purpose": f"氢化反应: 保持 {temperature}°C，反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
             }
         })
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"HYDROGENATE: 模拟优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
+            
     else:
         print(f"HYDROGENATE: 警告 - 未找到加热器，使用室温反应")
+        
+        # 🕐 室温反应也需要时间优化
+        print("HYDROGENATE: 检查室温反应模拟时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            print(f"HYDROGENATE: 室温反应时间优化: {original_reaction_time}s → {reaction_time}s")
+            print(f"HYDROGENATE: 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"HYDROGENATE: 室温反应时间在限制内: {reaction_time}s 保持不变")
+        
         # 室温反应，只等待时间
         action_sequence.append({
             "action_name": "wait",
             "action_kwargs": {
                 "time": reaction_time,
-                "description": f"室温氢化反应 {reaction_time/3600:.1f} 小时"
+                "description": f"室温氢化反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
             }
         })
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"HYDROGENATE: 室温反应优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
     
     # 7. 停止加热
     if heater_id:

unilabos/compile/recrystallize_protocol.py

@@ -1,8 +1,89 @@
 import networkx as nx
-from typing import List, Dict, Any, Tuple
+import re
+from typing import List, Dict, Any, Tuple, Union
 from .pump_protocol import generate_pump_protocol_with_rinsing
 
 
+def debug_print(message):
+    """调试输出"""
+    print(f"💎 [RECRYSTALLIZE] {message}", flush=True)
+
+
+def parse_volume_with_units(volume_input: Union[str, float, int], default_unit: str = "mL") -> float:
+    """
+    解析带单位的体积输入
+    
+    Args:
+        volume_input: 体积输入（如 "100 mL", "2.5 L", "500", "?", 100.0）
+        default_unit: 默认单位（默认为毫升）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if not volume_input:
+        debug_print("⚠️ 体积输入为空，返回 0.0mL 📦")
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(volume_input, (int, float)):
+        result = float(volume_input)
+        debug_print(f"🔢 数值体积输入: {volume_input} → {result}mL（默认单位）💧")
+        return result
+    
+    # 处理字符串输入
+    volume_str = str(volume_input).lower().strip()
+    debug_print(f"🔍 解析体积字符串: '{volume_str}' 📝")
+    
+    # 处理特殊值
+    if volume_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_volume = 50.0  # 50mL默认值
+        debug_print(f"❓ 检测到未知体积，使用默认值: {default_volume}mL 🎯")
+        return default_volume
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(volume_str)
+        if default_unit.lower() in ["ml", "milliliter"]:
+            result = value
+        elif default_unit.lower() in ["l", "liter"]:
+            result = value * 1000.0
+        elif default_unit.lower() in ["μl", "ul", "microliter"]:
+            result = value / 1000.0
+        else:
+            result = value  # 默认mL
+        debug_print(f"🔢 纯数字输入: {volume_str} → {result}mL（单位: {default_unit}）📏")
+        return result
+    except ValueError:
+        pass
+    
+    # 移除空格并提取数字和单位
+    volume_clean = re.sub(r'\s+', '', volume_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(ml|l|μl|ul|microliter|milliliter|liter)?', volume_clean)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析体积: '{volume_str}'，使用默认值: 50mL 🎯")
+        return 50.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit.lower()
+    
+    # 转换为毫升
+    if unit in ['l', 'liter']:
+        volume = value * 1000.0  # L -> mL
+        debug_print(f"📏 升转毫升: {value}L → {volume}mL 💧")
+    elif unit in ['μl', 'ul', 'microliter']:
+        volume = value / 1000.0  # μL -> mL
+        debug_print(f"📏 微升转毫升: {value}μL → {volume}mL 💧")
+    else:  # ml, milliliter 或默认
+        volume = value  # 已经是mL
+        debug_print(f"📏 毫升单位: {value}mL → {volume}mL 💧")
+    
+    debug_print(f"✅ 体积解析完成: '{volume_str}' → {volume}mL ✨")
+    return volume
+
+
 def parse_ratio(ratio_str: str) -> Tuple[float, float]:
     """
     解析比例字符串，支持多种格式
@@ -13,6 +94,8 @@ def parse_ratio(ratio_str: str) -> Tuple[float, float]:
     Returns:
         Tuple[float, float]: 比例元组 (ratio1, ratio2)
     """
+    debug_print(f"⚖️ 开始解析比例: '{ratio_str}' 📊")
+    
     try:
         # 处理 "1:1", "3:7", "50:50" 等格式
         if ":" in ratio_str:
@@ -20,6 +103,7 @@ def parse_ratio(ratio_str: str) -> Tuple[float, float]:
             if len(parts) == 2:
                 ratio1 = float(parts[0])
                 ratio2 = float(parts[1])
+                debug_print(f"✅ 冒号格式解析成功: {ratio1}:{ratio2} 🎯")
                 return ratio1, ratio2
         
         # 处理 "1-1", "3-7" 等格式
@@ -28,6 +112,7 @@ def parse_ratio(ratio_str: str) -> Tuple[float, float]:
             if len(parts) == 2:
                 ratio1 = float(parts[0])
                 ratio2 = float(parts[1])
+                debug_print(f"✅ 横线格式解析成功: {ratio1}:{ratio2} 🎯")
                 return ratio1, ratio2
         
         # 处理 "1,1", "3,7" 等格式
@@ -36,14 +121,15 @@ def parse_ratio(ratio_str: str) -> Tuple[float, float]:
             if len(parts) == 2:
                 ratio1 = float(parts[0])
                 ratio2 = float(parts[1])
+                debug_print(f"✅ 逗号格式解析成功: {ratio1}:{ratio2} 🎯")
                 return ratio1, ratio2
         
         # 默认 1:1
-        print(f"RECRYSTALLIZE: 无法解析比例 '{ratio_str}'，使用默认比例 1:1")
+        debug_print(f"⚠️ 无法解析比例 '{ratio_str}'，使用默认比例 1:1 🎭")
         return 1.0, 1.0
     
     except ValueError:
-        print(f"RECRYSTALLIZE: 比例解析错误 '{ratio_str}'，使用默认比例 1:1")
+        debug_print(f"❌ 比例解析错误 '{ratio_str}'，使用默认比例 1:1 🎭")
         return 1.0, 1.0
 
 
@@ -58,7 +144,7 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
     Returns:
         str: 溶剂容器ID
     """
-    print(f"RECRYSTALLIZE: 正在查找溶剂 '{solvent}' 的容器...")
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器... 🧪")
     
     # 构建可能的容器名称
     possible_names = [
@@ -72,22 +158,27 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
         f"vessel_{solvent}",
     ]
     
+    debug_print(f"📋 候选容器名称: {possible_names[:3]}... (共{len(possible_names)}个) 📝")
+    
     # 第一步：通过容器名称匹配
+    debug_print("  🎯 步骤1: 精确名称匹配...")
     for vessel_name in possible_names:
         if vessel_name in G.nodes():
-            print(f"RECRYSTALLIZE: 通过名称匹配找到容器: {vessel_name}")
+            debug_print(f"  🎉 通过名称匹配找到容器: {vessel_name} ✨")
             return vessel_name
     
     # 第二步：通过模糊匹配
+    debug_print("  🔍 步骤2: 模糊名称匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             node_name = G.nodes[node_id].get('name', '').lower()
             
             if solvent.lower() in node_id.lower() or solvent.lower() in node_name:
-                print(f"RECRYSTALLIZE: 通过模糊匹配找到容器: {node_id}")
+                debug_print(f"  🎉 通过模糊匹配找到容器: {node_id} ✨")
                 return node_id
     
     # 第三步：通过液体类型匹配
+    debug_print("  🧪 步骤3: 液体类型匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             vessel_data = G.nodes[node_id].get('data', {})
@@ -99,9 +190,10 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
                     reagent_name = vessel_data.get('reagent_name', '').lower()
                     
                     if solvent.lower() in liquid_type or solvent.lower() in reagent_name:
-                        print(f"RECRYSTALLIZE: 通过液体类型匹配找到容器: {node_id}")
+                        debug_print(f"  🎉 通过液体类型匹配找到容器: {node_id} ✨")
                         return node_id
     
+    debug_print(f"❌ 找不到溶剂 '{solvent}' 对应的容器 😭")
     raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器")
 
 
@@ -111,11 +203,11 @@ def generate_recrystallize_protocol(
     solvent1: str,
     solvent2: str,
     vessel: str,
-    volume: float,
-    **kwargs  # 接收其他可能的参数但不使用
+    volume: Union[str, float],  # 🔧 修改：支持字符串和数值
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成重结晶协议序列
+    生成重结晶协议序列 - 支持单位
     
     Args:
         G: 有向图，节点为容器和设备
@@ -123,72 +215,95 @@ def generate_recrystallize_protocol(
         solvent1: 第一种溶剂名称
         solvent2: 第二种溶剂名称
         vessel: 目标容器
-        volume: 总体积 (mL)
-        **kwargs: 其他可选参数，但不使用
+        volume: 总体积（支持 "100 mL", "50", "2.5 L" 等）
+        **kwargs: 其他可选参数
     
     Returns:
         List[Dict[str, Any]]: 动作序列
     """
     action_sequence = []
     
-    print(f"RECRYSTALLIZE: 开始生成重结晶协议")
-    print(f"  - 比例: {ratio}")
-    print(f"  - 溶剂1: {solvent1}")
-    print(f"  - 溶剂2: {solvent2}")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 总体积: {volume} mL")
+    debug_print("💎" * 20)
+    debug_print("🚀 开始生成重结晶协议（支持单位）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  ⚖️ 比例: {ratio}")
+    debug_print(f"  🧪 溶剂1: {solvent1}")
+    debug_print(f"  🧪 溶剂2: {solvent2}")
+    debug_print(f"  🥽 容器: {vessel}")
+    debug_print(f"  💧 总体积: {volume} (类型: {type(volume)})")
+    debug_print("💎" * 20)
     
     # 1. 验证目标容器存在
+    debug_print("📍 步骤1: 验证目标容器... 🔧")
     if vessel not in G.nodes():
+        debug_print(f"❌ 目标容器 '{vessel}' 不存在于系统中! 😱")
         raise ValueError(f"目标容器 '{vessel}' 不存在于系统中")
+    debug_print(f"✅ 目标容器 '{vessel}' 验证通过 🎯")
     
-    # 2. 解析比例
+    # 2. 🔧 新增：解析体积（支持单位）
+    debug_print("📍 步骤2: 解析体积（支持单位）... 💧")
+    final_volume = parse_volume_with_units(volume, "mL")
+    debug_print(f"🎯 体积解析完成: {volume} → {final_volume}mL ✨")
+    
+    # 3. 解析比例
+    debug_print("📍 步骤3: 解析比例... ⚖️")
     ratio1, ratio2 = parse_ratio(ratio)
     total_ratio = ratio1 + ratio2
+    debug_print(f"🎯 比例解析完成: {ratio1}:{ratio2} (总比例: {total_ratio}) ✨")
     
-    # 3. 计算各溶剂体积
-    volume1 = volume * (ratio1 / total_ratio)
-    volume2 = volume * (ratio2 / total_ratio)
+    # 4. 计算各溶剂体积
+    debug_print("📍 步骤4: 计算各溶剂体积... 🧮")
+    volume1 = final_volume * (ratio1 / total_ratio)
+    volume2 = final_volume * (ratio2 / total_ratio)
     
-    print(f"RECRYSTALLIZE: 解析比例: {ratio1}:{ratio2}")
-    print(f"RECRYSTALLIZE: {solvent1} 体积: {volume1:.2f} mL")
-    print(f"RECRYSTALLIZE: {solvent2} 体积: {volume2:.2f} mL")
+    debug_print(f"🧪 {solvent1} 体积: {volume1:.2f} mL ({ratio1}/{total_ratio} × {final_volume})")
+    debug_print(f"🧪 {solvent2} 体积: {volume2:.2f} mL ({ratio2}/{total_ratio} × {final_volume})")
+    debug_print(f"✅ 体积计算完成: 总计 {volume1 + volume2:.2f} mL 🎯")
     
-    # 4. 查找溶剂容器
+    # 5. 查找溶剂容器
+    debug_print("📍 步骤5: 查找溶剂容器... 🔍")
     try:
+        debug_print(f"  🔍 查找溶剂1容器...")
         solvent1_vessel = find_solvent_vessel(G, solvent1)
-        print(f"RECRYSTALLIZE: 找到溶剂1容器: {solvent1_vessel}")
+        debug_print(f"  🎉 找到溶剂1容器: {solvent1_vessel} ✨")
     except ValueError as e:
+        debug_print(f"  ❌ 溶剂1容器查找失败: {str(e)} 😭")
         raise ValueError(f"无法找到溶剂1 '{solvent1}': {str(e)}")
     
     try:
+        debug_print(f"  🔍 查找溶剂2容器...")
         solvent2_vessel = find_solvent_vessel(G, solvent2)
-        print(f"RECRYSTALLIZE: 找到溶剂2容器: {solvent2_vessel}")
+        debug_print(f"  🎉 找到溶剂2容器: {solvent2_vessel} ✨")
     except ValueError as e:
+        debug_print(f"  ❌ 溶剂2容器查找失败: {str(e)} 😭")
         raise ValueError(f"无法找到溶剂2 '{solvent2}': {str(e)}")
     
-    # 5. 验证路径存在
+    # 6. 验证路径存在
+    debug_print("📍 步骤6: 验证传输路径... 🛤️")
     try:
         path1 = nx.shortest_path(G, source=solvent1_vessel, target=vessel)
-        print(f"RECRYSTALLIZE: 溶剂1路径: {' → '.join(path1)}")
+        debug_print(f"  🛤️ 溶剂1路径: {' → '.join(path1)} ✅")
     except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂1路径不可达: {solvent1_vessel} → {vessel} 😞")
         raise ValueError(f"从溶剂1容器 '{solvent1_vessel}' 到目标容器 '{vessel}' 没有可用路径")
     
     try:
         path2 = nx.shortest_path(G, source=solvent2_vessel, target=vessel)
-        print(f"RECRYSTALLIZE: 溶剂2路径: {' → '.join(path2)}")
+        debug_print(f"  🛤️ 溶剂2路径: {' → '.join(path2)} ✅")
     except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂2路径不可达: {solvent2_vessel} → {vessel} 😞")
         raise ValueError(f"从溶剂2容器 '{solvent2_vessel}' 到目标容器 '{vessel}' 没有可用路径")
     
-    # 6. 添加第一种溶剂
-    print(f"RECRYSTALLIZE: 开始添加溶剂1 {volume1:.2f} mL")
+    # 7. 添加第一种溶剂
+    debug_print("📍 步骤7: 添加第一种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂1: {solvent1} ({volume1:.2f} mL)")
     
     try:
         pump_actions1 = generate_pump_protocol_with_rinsing(
             G=G,
             from_vessel=solvent1_vessel,
             to_vessel=vessel,
-            volume=volume1,
+            volume=volume1,             # 使用解析后的体积
             amount="",
             time=0.0,
             viscous=False,
@@ -201,28 +316,33 @@ def generate_recrystallize_protocol(
         )
         
         action_sequence.extend(pump_actions1)
+        debug_print(f"  ✅ 溶剂1泵送动作已添加: {len(pump_actions1)} 个动作 🚰✨")
         
     except Exception as e:
+        debug_print(f"  ❌ 溶剂1泵协议生成失败: {str(e)} 😭")
         raise ValueError(f"生成溶剂1泵协议时出错: {str(e)}")
     
-    # 7. 等待溶剂1稳定
+    # 8. 等待溶剂1稳定
+    debug_print("  ⏳ 添加溶剂1稳定等待...")
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 10.0,
+            "time": 5.0,  # 🕐 缩短等待时间：10.0s → 5.0s
             "description": f"等待溶剂1 {solvent1} 稳定"
         }
     })
+    debug_print("  ✅ 溶剂1稳定等待已添加 ⏰✨")
     
-    # 8. 添加第二种溶剂
-    print(f"RECRYSTALLIZE: 开始添加溶剂2 {volume2:.2f} mL")
+    # 9. 添加第二种溶剂
+    debug_print("📍 步骤8: 添加第二种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂2: {solvent2} ({volume2:.2f} mL)")
     
     try:
         pump_actions2 = generate_pump_protocol_with_rinsing(
             G=G,
             from_vessel=solvent2_vessel,
             to_vessel=vessel,
-            volume=volume2,
+            volume=volume2,             # 使用解析后的体积
             amount="",
             time=0.0,
             viscous=False,
@@ -235,30 +355,63 @@ def generate_recrystallize_protocol(
         )
         
         action_sequence.extend(pump_actions2)
+        debug_print(f"  ✅ 溶剂2泵送动作已添加: {len(pump_actions2)} 个动作 🚰✨")
         
     except Exception as e:
+        debug_print(f"  ❌ 溶剂2泵协议生成失败: {str(e)} 😭")
         raise ValueError(f"生成溶剂2泵协议时出错: {str(e)}")
     
-    # 9. 等待溶剂2稳定
+    # 10. 等待溶剂2稳定
+    debug_print("  ⏳ 添加溶剂2稳定等待...")
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 10.0,
+            "time": 5.0,  # 🕐 缩短等待时间：10.0s → 5.0s
             "description": f"等待溶剂2 {solvent2} 稳定"
         }
     })
+    debug_print("  ✅ 溶剂2稳定等待已添加 ⏰✨")
+    
+    # 11. 等待重结晶完成
+    debug_print("📍 步骤9: 等待重结晶完成... 💎")
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_crystallize_time = 600.0  # 原始重结晶时间
+    simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+
+    final_crystallize_time = min(original_crystallize_time, simulation_time_limit)
+    
+    if original_crystallize_time > simulation_time_limit:
+        debug_print(f"  🎮 模拟运行优化: {original_crystallize_time}s → {final_crystallize_time}s ⚡")
+        debug_print(f"  📊 时间缩短: {original_crystallize_time/60:.1f}分钟 → {final_crystallize_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_crystallize_time}s 保持不变 🎯")
     
-    # 10. 等待重结晶完成
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 600.0,  # 等待10分钟进行重结晶
-            "description": f"等待重结晶完成（{solvent1}:{solvent2} = {ratio}）"
+            "time": final_crystallize_time,
+            "description": f"等待重结晶完成（{solvent1}:{solvent2} = {ratio}，总体积 {final_volume}mL）" + (f" (模拟时间)" if original_crystallize_time != final_crystallize_time else "")
         }
     })
+    debug_print(f"  ✅ 重结晶等待已添加: {final_crystallize_time}s 💎✨")
     
-    print(f"RECRYSTALLIZE: 协议生成完成，共 {len(action_sequence)} 个动作")
-    print(f"RECRYSTALLIZE: 预计总时间: {620/60:.1f} 分钟")
+    # 显示时间调整信息
+    if original_crystallize_time != final_crystallize_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_crystallize_time/60:.1f}分钟，实际模拟 {final_crystallize_time/60:.1f}分钟 ⚡")
+    
+    # 🎊 总结
+    debug_print("💎" * 20)
+    debug_print(f"🎉 重结晶协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 目标容器: {vessel}")
+    debug_print(f"💧 总体积: {final_volume}mL")
+    debug_print(f"⚖️ 溶剂比例: {solvent1}:{solvent2} = {ratio1}:{ratio2}")
+    debug_print(f"🧪 溶剂1: {solvent1} ({volume1:.2f}mL)")
+    debug_print(f"🧪 溶剂2: {solvent2} ({volume2:.2f}mL)")
+    debug_print(f"⏱️ 预计总时间: {(final_crystallize_time + 10)/60:.1f} 分钟 ⌛")
+    debug_print("💎" * 20)
     
     return action_sequence
 
@@ -266,15 +419,16 @@ def generate_recrystallize_protocol(
 # 测试函数
 def test_recrystallize_protocol():
     """测试重结晶协议"""
-    print("=== RECRYSTALLIZE PROTOCOL 测试 ===")
+    debug_print("🧪 === RECRYSTALLIZE PROTOCOL 测试 === ✨")
     
     # 测试比例解析
+    debug_print("⚖️ 测试比例解析...")
     test_ratios = ["1:1", "3:7", "50:50", "1-1", "2,8", "invalid"]
     for ratio in test_ratios:
         r1, r2 = parse_ratio(ratio)
-        print(f"比例 '{ratio}' -> {r1}:{r2}")
+        debug_print(f"  📊 比例 '{ratio}' -> {r1}:{r2}")
     
-    print("测试完成")
+    debug_print("✅ 测试完成 🎉")
 
 
 if __name__ == "__main__":

unilabos/compile/reset_handling_protocol.py

@@ -3,6 +3,11 @@ from typing import List, Dict, Any
 from .pump_protocol import generate_pump_protocol_with_rinsing
 
 
+def debug_print(message):
+    """调试输出"""
+    print(f"🔄 [RESET_HANDLING] {message}", flush=True)
+
+
 def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
     """
     查找溶剂容器，支持多种匹配模式
@@ -14,7 +19,7 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
     Returns:
         str: 溶剂容器ID
     """
-    print(f"RESET_HANDLING: 正在查找溶剂 '{solvent}' 的容器...")
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器... 🧪")
     
     # 构建可能的容器名称
     possible_names = [
@@ -28,23 +33,30 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
         f"vessel_{solvent}",          # vessel_methanol
     ]
     
+    debug_print(f"📋 候选容器名称: {possible_names[:3]}... (共{len(possible_names)}个) 📝")
+    
     # 第一步：通过容器名称匹配
+    debug_print("  🎯 步骤1: 精确名称匹配...")
     for vessel_name in possible_names:
         if vessel_name in G.nodes():
-            print(f"RESET_HANDLING: 通过名称匹配找到容器: {vessel_name}")
+            debug_print(f"  🎉 通过名称匹配找到容器: {vessel_name} ✨")
             return vessel_name
+    debug_print("  😞 精确名称匹配失败，尝试模糊匹配... 🔍")
     
     # 第二步：通过模糊匹配
+    debug_print("  🔍 步骤2: 模糊名称匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             node_name = G.nodes[node_id].get('name', '').lower()
             
             # 检查是否包含溶剂名称
             if solvent.lower() in node_id.lower() or solvent.lower() in node_name:
-                print(f"RESET_HANDLING: 通过模糊匹配找到容器: {node_id}")
+                debug_print(f"  🎉 通过模糊匹配找到容器: {node_id} ✨")
                 return node_id
+    debug_print("  😞 模糊匹配失败，尝试液体类型匹配... 🧪")
     
     # 第三步：通过液体类型匹配
+    debug_print("  🧪 步骤3: 液体类型匹配...")
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
             vessel_data = G.nodes[node_id].get('data', {})
@@ -56,10 +68,11 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
                     reagent_name = vessel_data.get('reagent_name', '').lower()
                     
                     if solvent.lower() in liquid_type or solvent.lower() in reagent_name:
-                        print(f"RESET_HANDLING: 通过液体类型匹配找到容器: {node_id}")
+                        debug_print(f"  🎉 通过液体类型匹配找到容器: {node_id} ✨")
                         return node_id
     
     # 列出可用容器帮助调试
+    debug_print("  📊 显示可用容器信息...")
     available_containers = []
     for node_id in G.nodes():
         if G.nodes[node_id].get('type') == 'container':
@@ -75,13 +88,17 @@ def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
                 'reagent_name': vessel_data.get('reagent_name', '')
             })
     
-    print(f"RESET_HANDLING: 可用容器列表:")
-    for container in available_containers:
-        print(f"  - {container['id']}: {container['name']}")
-        print(f"    液体: {container['liquids']}")
-        print(f"    试剂: {container['reagent_name']}")
+    debug_print(f"  📋 可用容器列表 (共{len(available_containers)}个):")
+    for i, container in enumerate(available_containers[:5]):  # 只显示前5个
+        debug_print(f"    {i+1}. 🥽 {container['id']}: {container['name']}")
+        debug_print(f"       💧 液体: {container['liquids']}")
+        debug_print(f"       🧪 试剂: {container['reagent_name']}")
     
-    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器。尝试了: {possible_names}")
+    if len(available_containers) > 5:
+        debug_print(f"    ... 还有 {len(available_containers)-5} 个容器 📦")
+    
+    debug_print(f"❌ 找不到溶剂 '{solvent}' 对应的容器 😭")
+    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器。尝试了: {possible_names[:3]}...")
 
 
 def generate_reset_handling_protocol(
@@ -104,35 +121,49 @@ def generate_reset_handling_protocol(
     
     # 固定参数
     target_vessel = "main_reactor"  # 默认目标容器
-    volume = 100.0  # 默认体积 100 mL
-    
-    print(f"RESET_HANDLING: 开始生成重置处理协议")
-    print(f"  - 溶剂: {solvent}")
-    print(f"  - 目标容器: {target_vessel}")
-    print(f"  - 体积: {volume} mL")
+    volume = 50.0  # 默认体积 50 mL
+
+    debug_print("🔄" * 20)
+    debug_print("🚀 开始生成重置处理协议 ✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🧪 溶剂: {solvent}")
+    debug_print(f"  🥽 目标容器: {target_vessel}")
+    debug_print(f"  💧 体积: {volume} mL")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("🔄" * 20)
     
     # 1. 验证目标容器存在
+    debug_print("📍 步骤1: 验证目标容器... 🔧")
     if target_vessel not in G.nodes():
+        debug_print(f"❌ 目标容器 '{target_vessel}' 不存在于系统中! 😱")
         raise ValueError(f"目标容器 '{target_vessel}' 不存在于系统中")
+    debug_print(f"✅ 目标容器 '{target_vessel}' 验证通过 🎯")
     
     # 2. 查找溶剂容器
+    debug_print("📍 步骤2: 查找溶剂容器... 🔍")
     try:
         solvent_vessel = find_solvent_vessel(G, solvent)
-        print(f"RESET_HANDLING: 找到溶剂容器: {solvent_vessel}")
+        debug_print(f"🎉 找到溶剂容器: {solvent_vessel} ✨")
     except ValueError as e:
+        debug_print(f"❌ 溶剂容器查找失败: {str(e)} 😭")
         raise ValueError(f"无法找到溶剂 '{solvent}': {str(e)}")
     
     # 3. 验证路径存在
+    debug_print("📍 步骤3: 验证传输路径... 🛤️")
     try:
         path = nx.shortest_path(G, source=solvent_vessel, target=target_vessel)
-        print(f"RESET_HANDLING: 找到路径: {' → '.join(path)}")
+        debug_print(f"🛤️ 找到路径: {' → '.join(path)} ✅")
     except nx.NetworkXNoPath:
+        debug_print(f"❌ 路径不可达: {solvent_vessel} → {target_vessel} 😞")
         raise ValueError(f"从溶剂容器 '{solvent_vessel}' 到目标容器 '{target_vessel}' 没有可用路径")
     
     # 4. 使用pump_protocol转移溶剂
-    print(f"RESET_HANDLING: 开始转移溶剂 {volume} mL")
+    debug_print("📍 步骤4: 转移溶剂... 🚰")
+    debug_print(f"  🚛 开始转移: {solvent_vessel} → {target_vessel}")
+    debug_print(f"  💧 转移体积: {volume} mL")
     
     try:
+        debug_print("  🔄 生成泵送协议...")
         pump_actions = generate_pump_protocol_with_rinsing(
             G=G,
             from_vessel=solvent_vessel,
@@ -150,21 +181,52 @@ def generate_reset_handling_protocol(
         )
         
         action_sequence.extend(pump_actions)
+        debug_print(f"  ✅ 泵送协议已添加: {len(pump_actions)} 个动作 🚰✨")
         
     except Exception as e:
+        debug_print(f"  ❌ 泵送协议生成失败: {str(e)} 😭")
         raise ValueError(f"生成泵协议时出错: {str(e)}")
     
     # 5. 等待溶剂稳定
+    debug_print("📍 步骤5: 等待溶剂稳定... ⏳")
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_wait_time = 10.0  # 原始等待时间
+    simulation_time_limit = 5.0  # 模拟运行时间限制：5秒
+    
+    final_wait_time = min(original_wait_time, simulation_time_limit)
+    
+    if original_wait_time > simulation_time_limit:
+        debug_print(f"  🎮 模拟运行优化: {original_wait_time}s → {final_wait_time}s ⚡")
+        debug_print(f"  📊 时间缩短: {original_wait_time}s → {final_wait_time}s 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_wait_time}s 保持不变 🎯")
+    
     action_sequence.append({
         "action_name": "wait",
         "action_kwargs": {
-            "time": 10.0,
-            "description": f"等待溶剂 {solvent} 稳定"
+            "time": final_wait_time,
+            "description": f"等待溶剂 {solvent} 稳定" + (f" (模拟时间)" if original_wait_time != final_wait_time else "")
         }
     })
+    debug_print(f"  ✅ 稳定等待已添加: {final_wait_time}s ⏰✨")
     
-    print(f"RESET_HANDLING: 协议生成完成，共 {len(action_sequence)} 个动作")
-    print(f"RESET_HANDLING: 已添加 {volume} mL {solvent} 到 {target_vessel}")
+    # 显示时间调整信息
+    if original_wait_time != final_wait_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_wait_time}s，实际模拟 {final_wait_time}s ⚡")
+    
+    # 🎊 总结
+    debug_print("🔄" * 20)
+    debug_print(f"🎉 重置处理协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🧪 溶剂: {solvent}")
+    debug_print(f"🥽 源容器: {solvent_vessel}")
+    debug_print(f"🥽 目标容器: {target_vessel}")
+    debug_print(f"💧 转移体积: {volume} mL")
+    debug_print(f"⏱️ 预计总时间: {(final_wait_time + 5):.0f} 秒 ⌛")
+    debug_print(f"🎯 已添加 {volume} mL {solvent} 到 {target_vessel} 🚰✨")
+    debug_print("🔄" * 20)
     
     return action_sequence
 
@@ -172,8 +234,15 @@ def generate_reset_handling_protocol(
 # 测试函数
 def test_reset_handling_protocol():
     """测试重置处理协议"""
-    print("=== RESET HANDLING PROTOCOL 测试 ===")
-    print("测试完成")
+    debug_print("🧪 === RESET HANDLING PROTOCOL 测试 === ✨")
+    
+    # 测试溶剂名称
+    debug_print("🧪 测试常用溶剂名称...")
+    test_solvents = ["methanol", "ethanol", "water", "acetone", "dmso"]
+    for solvent in test_solvents:
+        debug_print(f"  🔍 测试溶剂: {solvent}")
+    
+    debug_print("✅ 测试完成 🎉")
 
 
 if __name__ == "__main__":

unilabos/compile/run_column_protocol.py

@@ -1,312 +1,646 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
-from .pump_protocol import generate_pump_protocol
+import logging
+import re
+from .pump_protocol import generate_pump_protocol_with_rinsing
 
+logger = logging.getLogger(__name__)
 
-def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
-    """获取容器中的液体体积"""
-    if vessel not in G.nodes():
+def debug_print(message):
+    """调试输出"""
+    print(f"[RUN_COLUMN] {message}", flush=True)
+    logger.info(f"[RUN_COLUMN] {message}")
+
+def parse_percentage(pct_str: str) -> float:
+    """
+    解析百分比字符串为数值
+    
+    Args:
+        pct_str: 百分比字符串（如 "40 %", "40%", "40"）
+    
+    Returns:
+        float: 百分比数值（0-100）
+    """
+    if not pct_str or not pct_str.strip():
         return 0.0
     
-    vessel_data = G.nodes[vessel].get('data', {})
-    liquids = vessel_data.get('liquid', [])
+    pct_str = pct_str.strip().lower()
+    debug_print(f"解析百分比: '{pct_str}'")
     
-    total_volume = 0.0
-    for liquid in liquids:
-        if isinstance(liquid, dict):
-            # 支持两种格式：新格式 (name, volume) 和旧格式 (liquid_type, liquid_volume)
-            volume = liquid.get('volume') or liquid.get('liquid_volume', 0.0)
-            total_volume += volume
+    # 移除百分号和空格
+    pct_clean = re.sub(r'[%\s]', '', pct_str)
     
-    return total_volume
+    # 提取数字
+    match = re.search(r'([0-9]*\.?[0-9]+)', pct_clean)
+    if match:
+        value = float(match.group(1))
+        debug_print(f"百分比解析结果: {value}%")
+        return value
+    
+    debug_print(f"⚠️ 无法解析百分比: '{pct_str}'，返回0.0")
+    return 0.0
 
+def parse_ratio(ratio_str: str) -> tuple:
+    """
+    解析比例字符串为两个数值
+    
+    Args:
+        ratio_str: 比例字符串（如 "5:95", "1:1", "40:60"）
+    
+    Returns:
+        tuple: (ratio1, ratio2) 两个比例值
+    """
+    if not ratio_str or not ratio_str.strip():
+        return (50.0, 50.0)  # 默认1:1
+    
+    ratio_str = ratio_str.strip()
+    debug_print(f"解析比例: '{ratio_str}'")
+    
+    # 支持多种分隔符：: / -
+    if ':' in ratio_str:
+        parts = ratio_str.split(':')
+    elif '/' in ratio_str:
+        parts = ratio_str.split('/')
+    elif '-' in ratio_str:
+        parts = ratio_str.split('-')
+    elif 'to' in ratio_str.lower():
+        parts = ratio_str.lower().split('to')
+    else:
+        debug_print(f"⚠️ 无法解析比例格式: '{ratio_str}'，使用默认1:1")
+        return (50.0, 50.0)
+    
+    if len(parts) >= 2:
+        try:
+            ratio1 = float(parts[0].strip())
+            ratio2 = float(parts[1].strip())
+            total = ratio1 + ratio2
+            
+            # 转换为百分比
+            pct1 = (ratio1 / total) * 100
+            pct2 = (ratio2 / total) * 100
+            
+            debug_print(f"比例解析结果: {ratio1}:{ratio2} -> {pct1:.1f}%:{pct2:.1f}%")
+            return (pct1, pct2)
+        except ValueError as e:
+            debug_print(f"⚠️ 比例数值转换失败: {str(e)}")
+    
+    debug_print(f"⚠️ 比例解析失败，使用默认1:1")
+    return (50.0, 50.0)
 
-def find_column_device(G: nx.DiGraph, column: str) -> str:
+def parse_rf_value(rf_str: str) -> float:
+    """
+    解析Rf值字符串
+    
+    Args:
+        rf_str: Rf值字符串（如 "0.3", "0.45", "?"）
+    
+    Returns:
+        float: Rf值（0-1）
+    """
+    if not rf_str or not rf_str.strip():
+        return 0.3  # 默认Rf值
+    
+    rf_str = rf_str.strip().lower()
+    debug_print(f"解析Rf值: '{rf_str}'")
+    
+    # 处理未知Rf值
+    if rf_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_rf = 0.3
+        debug_print(f"检测到未知Rf值，使用默认值: {default_rf}")
+        return default_rf
+    
+    # 提取数字
+    match = re.search(r'([0-9]*\.?[0-9]+)', rf_str)
+    if match:
+        value = float(match.group(1))
+        # 确保Rf值在0-1范围内
+        if value > 1.0:
+            value = value / 100.0  # 可能是百分比形式
+        value = max(0.0, min(1.0, value))  # 限制在0-1范围
+        debug_print(f"Rf值解析结果: {value}")
+        return value
+    
+    debug_print(f"⚠️ 无法解析Rf值: '{rf_str}'，使用默认值0.3")
+    return 0.3
+
+def find_column_device(G: nx.DiGraph) -> str:
     """查找柱层析设备"""
-    # 首先检查是否有虚拟柱设备
-    column_nodes = [node for node in G.nodes() 
-                   if (G.nodes[node].get('class') or '') == 'virtual_column']
+    debug_print("查找柱层析设备...")
     
-    if column_nodes:
-        return column_nodes[0]
+    # 查找虚拟柱设备
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'virtual_column' in node_class.lower() or 'column' in node_class.lower():
+            debug_print(f"✅ 找到柱层析设备: {node}")
+            return node
     
-    # 如果没有虚拟柱设备，抛出异常
-    raise ValueError(f"系统中未找到柱层析设备。请确保配置了 virtual_column 设备")
-
+    # 如果没有找到，尝试创建虚拟设备名称
+    possible_names = ['column_1', 'virtual_column_1', 'chromatography_column_1']
+    for name in possible_names:
+        if name in G.nodes():
+            debug_print(f"✅ 找到柱设备: {name}")
+            return name
+    
+    debug_print("⚠️ 未找到柱层析设备，将使用pump protocol直接转移")
+    return ""
 
 def find_column_vessel(G: nx.DiGraph, column: str) -> str:
     """查找柱容器"""
-    # 直接使用 column 参数作为容器名称
-    if column in G.nodes():
-        return column
+    debug_print(f"查找柱容器: '{column}'")
     
-    # 尝试常见的柱容器命名规则
+    # 直接检查column参数是否是容器
+    if column in G.nodes():
+        node_type = G.nodes[column].get('type', '')
+        if node_type == 'container':
+            debug_print(f"✅ 找到柱容器: {column}")
+            return column
+    
+    # 尝试常见的命名规则
     possible_names = [
         f"column_{column}",
-        f"{column}_column",
+        f"{column}_column", 
         f"vessel_{column}",
         f"{column}_vessel",
         "column_vessel",
         "chromatography_column",
         "silica_column",
-        "preparative_column"
+        "preparative_column",
+        "column"
     ]
     
     for vessel_name in possible_names:
         if vessel_name in G.nodes():
-            return vessel_name
+            node_type = G.nodes[vessel_name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"✅ 找到柱容器: {vessel_name}")
+                return vessel_name
     
-    raise ValueError(f"未找到柱容器 '{column}'。尝试了以下名称: {[column] + possible_names}")
+    debug_print(f"⚠️ 未找到柱容器，将直接在源容器中进行分离")
+    return ""
 
-
-def find_eluting_solvent_vessel(G: nx.DiGraph, eluting_solvent: str) -> str:
-    """查找洗脱溶剂容器"""
-    if not eluting_solvent:
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂容器 - 增强版"""
+    if not solvent or not solvent.strip():
         return ""
     
-    # 按照命名规则查找溶剂瓶
-    solvent_vessel_id = f"flask_{eluting_solvent}"
+    solvent = solvent.strip().replace(' ', '_').lower()
+    debug_print(f"查找溶剂容器: '{solvent}'")
     
-    if solvent_vessel_id in G.nodes():
-        return solvent_vessel_id
-    
-    # 如果直接匹配失败，尝试模糊匹配
+    # 🔧 方法1：直接搜索 data.reagent_name
     for node in G.nodes():
-        if node.startswith('flask_') and eluting_solvent.lower() in node.lower():
-            return node
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            reagent_config = G.nodes[node].get('config', {}).get('reagent', '').lower()
+            
+            # 检查 data.reagent_name 和 config.reagent
+            if reagent_name == solvent or reagent_config == solvent:
+                debug_print(f"✅ 通过reagent_name找到溶剂容器: {node} (reagent: {reagent_name or reagent_config})")
+                return node
+            
+            # 模糊匹配 reagent_name
+            if solvent in reagent_name or reagent_name in solvent:
+                debug_print(f"✅ 通过reagent_name模糊匹配到溶剂容器: {node} (reagent: {reagent_name})")
+                return node
+            
+            if solvent in reagent_config or reagent_config in solvent:
+                debug_print(f"✅ 通过config.reagent模糊匹配到溶剂容器: {node} (reagent: {reagent_config})")
+                return node
     
-    # 如果还是找不到，列出所有可用的溶剂瓶
-    available_flasks = [node for node in G.nodes() 
-                       if node.startswith('flask_') 
-                       and G.nodes[node].get('type') == 'container']
+    # 🔧 方法2：常见的溶剂容器命名规则
+    possible_names = [
+        f"flask_{solvent}",
+        f"bottle_{solvent}",
+        f"reagent_{solvent}",
+        f"{solvent}_bottle",
+        f"{solvent}_flask",
+        f"solvent_{solvent}",
+        f"reagent_bottle_{solvent}"
+    ]
     
-    raise ValueError(f"找不到洗脱溶剂 '{eluting_solvent}' 对应的溶剂瓶。可用溶剂瓶: {available_flasks}")
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            node_type = G.nodes[vessel_name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"✅ 通过命名规则找到溶剂容器: {vessel_name}")
+                return vessel_name
+    
+    # 🔧 方法3：节点名称模糊匹配
+    for node in G.nodes():
+        node_type = G.nodes[node].get('type', '')
+        if node_type == 'container':
+            if ('flask_' in node or 'bottle_' in node or 'reagent_' in node) and solvent in node.lower():
+                debug_print(f"✅ 通过节点名称模糊匹配到溶剂容器: {node}")
+                return node
+    
+    # 🔧 方法4：特殊溶剂名称映射
+    solvent_mapping = {
+        'dmf': ['dmf', 'dimethylformamide', 'n,n-dimethylformamide'],
+        'ethyl_acetate': ['ethyl_acetate', 'ethylacetate', 'etoac', 'ea'],
+        'hexane': ['hexane', 'hexanes', 'n-hexane'],
+        'methanol': ['methanol', 'meoh', 'ch3oh'],
+        'water': ['water', 'h2o', 'distilled_water'],
+        'acetone': ['acetone', 'ch3coch3', '2-propanone'],
+        'dichloromethane': ['dichloromethane', 'dcm', 'ch2cl2', 'methylene_chloride'],
+        'chloroform': ['chloroform', 'chcl3', 'trichloromethane']
+    }
+    
+    # 查找映射的同义词
+    for canonical_name, synonyms in solvent_mapping.items():
+        if solvent in synonyms:
+            debug_print(f"检测到溶剂同义词: '{solvent}' -> '{canonical_name}'")
+            return find_solvent_vessel(G, canonical_name)  # 递归搜索
+    
+    debug_print(f"⚠️ 未找到溶剂 '{solvent}' 的容器")
+    return ""
 
+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """获取容器中的液体体积 - 增强版"""
+    if vessel not in G.nodes():
+        debug_print(f"⚠️ 节点 '{vessel}' 不存在")
+        return 0.0
+    
+    node_type = G.nodes[vessel].get('type', '')
+    vessel_data = G.nodes[vessel].get('data', {})
+    
+    debug_print(f"读取节点 '{vessel}' (类型: {node_type}) 体积数据: {vessel_data}")
+    
+    # 🔧 如果是设备类型，尝试查找关联的容器
+    if node_type == 'device':
+        debug_print(f"'{vessel}' 是设备，尝试查找关联容器...")
+        
+        # 查找是否有内置容器数据
+        config_data = G.nodes[vessel].get('config', {})
+        if 'volume' in config_data:
+            default_volume = config_data.get('volume', 50.0)
+            debug_print(f"使用设备默认容量: {default_volume}mL")
+            return default_volume
+        
+        # 对于旋蒸等设备，使用默认值
+        if 'rotavap' in vessel.lower():
+            default_volume = 50.0
+            debug_print(f"旋蒸设备使用默认容量: {default_volume}mL")
+            return default_volume
+        
+        debug_print(f"⚠️ 设备 '{vessel}' 无法确定容量，返回0")
+        return 0.0
+    
+    # 🔧 如果是容器类型，正常读取体积
+    total_volume = 0.0
+    
+    # 方法1：检查液体列表
+    liquids = vessel_data.get('liquid', [])
+    if isinstance(liquids, list):
+        for liquid in liquids:
+            if isinstance(liquid, dict):
+                volume = liquid.get('volume') or liquid.get('liquid_volume', 0.0)
+                total_volume += volume
+    
+    # 方法2：检查直接体积字段
+    if total_volume == 0.0:
+        volume_keys = ['current_volume', 'total_volume', 'volume', 'liquid_volume']
+        for key in volume_keys:
+            if key in vessel_data:
+                try:
+                    total_volume = float(vessel_data[key])
+                    if total_volume > 0:
+                        break
+                except (ValueError, TypeError):
+                    continue
+    
+    # 方法3：检查配置中的初始体积
+    if total_volume == 0.0:
+        config_data = G.nodes[vessel].get('config', {})
+        if 'current_volume' in config_data:
+            try:
+                total_volume = float(config_data['current_volume'])
+            except (ValueError, TypeError):
+                pass
+    
+    debug_print(f"容器 '{vessel}' 总体积: {total_volume}mL")
+    return total_volume
+
+def calculate_solvent_volumes(total_volume: float, pct1: float, pct2: float) -> tuple:
+    """根据百分比计算溶剂体积"""
+    volume1 = (total_volume * pct1) / 100.0
+    volume2 = (total_volume * pct2) / 100.0
+    
+    debug_print(f"溶剂体积计算: 总体积{total_volume}mL")
+    debug_print(f"  - 溶剂1: {pct1}% = {volume1}mL")
+    debug_print(f"  - 溶剂2: {pct2}% = {volume2}mL")
+    
+    return (volume1, volume2)
 
 def generate_run_column_protocol(
     G: nx.DiGraph,
     from_vessel: str,
     to_vessel: str,
-    column: str
+    column: str,
+    rf: str = "",
+    pct1: str = "",
+    pct2: str = "",
+    solvent1: str = "",
+    solvent2: str = "",
+    ratio: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成柱层析分离的协议序列
+    生成柱层析分离的协议序列 - 增强版
+    
+    支持新版XDL的所有参数，具有高兼容性和容错性
     
     Args:
         G: 有向图，节点为设备和容器，边为流体管道
-        from_vessel: 源容器的名称，即样品起始所在的容器
-        to_vessel: 目标容器的名称，分离后的样品要到达的容器
-        column: 所使用的柱子的名称
+        from_vessel: 源容器的名称，即样品起始所在的容器（必需）
+        to_vessel: 目标容器的名称，分离后的样品要到达的容器（必需）
+        column: 所使用的柱子的名称（必需）
+        rf: Rf值（可选，支持 "?" 表示未知）
+        pct1: 第一种溶剂百分比（如 "40 %"，可选）
+        pct2: 第二种溶剂百分比（如 "50 %"，可选）
+        solvent1: 第一种溶剂名称（可选）
+        solvent2: 第二种溶剂名称（可选）
+        ratio: 溶剂比例（如 "5:95"，可选，优先级高于pct1/pct2）
+        **kwargs: 其他可选参数
     
     Returns:
         List[Dict[str, Any]]: 柱层析分离操作的动作序列
     """
+    
+    debug_print("=" * 60)
+    debug_print("开始生成柱层析协议")
+    debug_print(f"输入参数:")
+    debug_print(f"  - from_vessel: '{from_vessel}'")
+    debug_print(f"  - to_vessel: '{to_vessel}'")
+    debug_print(f"  - column: '{column}'")
+    debug_print(f"  - rf: '{rf}'")
+    debug_print(f"  - pct1: '{pct1}'")
+    debug_print(f"  - pct2: '{pct2}'")
+    debug_print(f"  - solvent1: '{solvent1}'")
+    debug_print(f"  - solvent2: '{solvent2}'")
+    debug_print(f"  - ratio: '{ratio}'")
+    debug_print(f"  - 其他参数: {kwargs}")
+    debug_print("=" * 60)
+    
     action_sequence = []
     
-    print(f"RUN_COLUMN: 开始生成柱层析协议")
-    print(f"  - 源容器: {from_vessel}")
-    print(f"  - 目标容器: {to_vessel}")
-    print(f"  - 柱子: {column}")
+    # === 参数验证 ===
+    debug_print("步骤1: 参数验证...")
+    
+    if not from_vessel:
+        raise ValueError("from_vessel 参数不能为空")
+    if not to_vessel:
+        raise ValueError("to_vessel 参数不能为空")
+    if not column:
+        raise ValueError("column 参数不能为空")
     
-    # 验证源容器和目标容器存在
     if from_vessel not in G.nodes():
         raise ValueError(f"源容器 '{from_vessel}' 不存在于系统中")
-    
     if to_vessel not in G.nodes():
         raise ValueError(f"目标容器 '{to_vessel}' 不存在于系统中")
     
-    # 查找柱层析设备
-    column_device_id = None
-    column_nodes = [node for node in G.nodes() 
-                   if (G.nodes[node].get('class') or '') == 'virtual_column']
+    debug_print("✅ 基本参数验证通过")
     
-    if column_nodes:
-        column_device_id = column_nodes[0]
-        print(f"RUN_COLUMN: 找到柱层析设备: {column_device_id}")
+    # === 参数解析 ===
+    debug_print("步骤2: 参数解析...")
+    
+    # 解析Rf值
+    final_rf = parse_rf_value(rf)
+    debug_print(f"最终Rf值: {final_rf}")
+    
+    # 解析溶剂比例（ratio优先级高于pct1/pct2）
+    if ratio and ratio.strip():
+        final_pct1, final_pct2 = parse_ratio(ratio)
+        debug_print(f"使用ratio参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
     else:
-        print(f"RUN_COLUMN: 警告 - 未找到柱层析设备")
+        final_pct1 = parse_percentage(pct1) if pct1 else 50.0
+        final_pct2 = parse_percentage(pct2) if pct2 else 50.0
+        
+        # 如果百分比和不是100%，进行归一化
+        total_pct = final_pct1 + final_pct2
+        if total_pct == 0:
+            final_pct1, final_pct2 = 50.0, 50.0
+        elif total_pct != 100.0:
+            final_pct1 = (final_pct1 / total_pct) * 100
+            final_pct2 = (final_pct2 / total_pct) * 100
+        
+        debug_print(f"使用百分比参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
+    
+    # 设置默认溶剂（如果未指定）
+    final_solvent1 = solvent1.strip() if solvent1 else "ethyl_acetate"
+    final_solvent2 = solvent2.strip() if solvent2 else "hexane"
+    
+    debug_print(f"最终溶剂: {final_solvent1} : {final_solvent2}")
+    
+    # === 查找设备和容器 ===
+    debug_print("步骤3: 查找设备和容器...")
+    
+    # 查找柱层析设备
+    column_device_id = find_column_device(G)
+    
+    # 查找柱容器
+    column_vessel = find_column_vessel(G, column)
+    
+    # 查找溶剂容器
+    solvent1_vessel = find_solvent_vessel(G, final_solvent1)
+    solvent2_vessel = find_solvent_vessel(G, final_solvent2)
+    
+    debug_print(f"设备映射:")
+    debug_print(f"  - 柱设备: '{column_device_id}'")
+    debug_print(f"  - 柱容器: '{column_vessel}'")
+    debug_print(f"  - 溶剂1容器: '{solvent1_vessel}'")
+    debug_print(f"  - 溶剂2容器: '{solvent2_vessel}'")
+    
+    # === 获取源容器体积 ===
+    debug_print("步骤4: 获取源容器体积...")
     
-    # 获取源容器中的液体体积
     source_volume = get_vessel_liquid_volume(G, from_vessel)
-    print(f"RUN_COLUMN: 源容器 {from_vessel} 中有 {source_volume} mL 液体")
+    if source_volume <= 0:
+        source_volume = 50.0  # 默认体积
+        debug_print(f"⚠️ 无法获取源容器体积，使用默认值: {source_volume}mL")
+    else:
+        debug_print(f"✅ 源容器体积: {source_volume}mL")
     
-    # === 第一步：样品转移到柱子（如果柱子是容器） ===
-    if column in G.nodes() and G.nodes[column].get('type') == 'container':
-        print(f"RUN_COLUMN: 样品转移 - {source_volume} mL 从 {from_vessel} 到 {column}")
-        
-        try:
-            sample_transfer_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=from_vessel,
-                to_vessel=column,
-                volume=source_volume if source_volume > 0 else 100.0,
-                flowrate=2.0
-            )
-            action_sequence.extend(sample_transfer_actions)
-        except Exception as e:
-            print(f"RUN_COLUMN: 样品转移失败: {str(e)}")
+    # === 计算溶剂体积 ===
+    debug_print("步骤5: 计算溶剂体积...")
     
-    # === 第二步：使用柱层析设备执行分离 ===
-    if column_device_id:
-        print(f"RUN_COLUMN: 使用柱层析设备执行分离")
+    # 洗脱溶剂通常是样品体积的2-5倍
+    total_elution_volume = source_volume * 3.0
+    solvent1_volume, solvent2_volume = calculate_solvent_volumes(
+        total_elution_volume, final_pct1, final_pct2
+    )
+    
+    # === 执行柱层析流程 ===
+    debug_print("步骤6: 执行柱层析流程...")
+    
+    try:
+        # 步骤6.1: 样品上柱（如果有独立的柱容器）
+        if column_vessel and column_vessel != from_vessel:
+            debug_print(f"6.1: 样品上柱 - {source_volume}mL 从 {from_vessel} 到 {column_vessel}")
+            
+            try:
+                sample_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=from_vessel,
+                    to_vessel=column_vessel,
+                    volume=source_volume,
+                    flowrate=1.0,  # 慢速上柱
+                    transfer_flowrate=0.5,
+                    rinsing_solvent="",  # 暂不冲洗
+                    rinsing_volume=0.0,
+                    rinsing_repeats=0
+                )
+                action_sequence.extend(sample_transfer_actions)
+                debug_print(f"✅ 样品上柱完成，添加了 {len(sample_transfer_actions)} 个动作")
+            except Exception as e:
+                debug_print(f"⚠️ 样品上柱失败: {str(e)}")
         
-        column_separation_action = {
-            "device_id": column_device_id,
-            "action_name": "run_column",
-            "action_kwargs": {
-                "from_vessel": from_vessel,
-                "to_vessel": to_vessel,
-                "column": column
+        # 步骤6.2: 添加洗脱溶剂1（如果有溶剂容器）
+        if solvent1_vessel and solvent1_volume > 0:
+            debug_print(f"6.2: 添加洗脱溶剂1 - {solvent1_volume:.1f}mL {final_solvent1}")
+            
+            try:
+                target_vessel = column_vessel if column_vessel else from_vessel
+                solvent1_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=solvent1_vessel,
+                    to_vessel=target_vessel,
+                    volume=solvent1_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(solvent1_transfer_actions)
+                debug_print(f"✅ 溶剂1添加完成，添加了 {len(solvent1_transfer_actions)} 个动作")
+            except Exception as e:
+                debug_print(f"⚠️ 溶剂1添加失败: {str(e)}")
+        
+        # 步骤6.3: 添加洗脱溶剂2（如果有溶剂容器）
+        if solvent2_vessel and solvent2_volume > 0:
+            debug_print(f"6.3: 添加洗脱溶剂2 - {solvent2_volume:.1f}mL {final_solvent2}")
+            
+            try:
+                target_vessel = column_vessel if column_vessel else from_vessel
+                solvent2_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=solvent2_vessel,
+                    to_vessel=target_vessel,
+                    volume=solvent2_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(solvent2_transfer_actions)
+                debug_print(f"✅ 溶剂2添加完成，添加了 {len(solvent2_transfer_actions)} 个动作")
+            except Exception as e:
+                debug_print(f"⚠️ 溶剂2添加失败: {str(e)}")
+        
+        # 步骤6.4: 使用柱层析设备执行分离（如果有设备）
+        if column_device_id:
+            debug_print(f"6.4: 使用柱层析设备执行分离")
+            
+            column_separation_action = {
+                "device_id": column_device_id,
+                "action_name": "run_column",
+                "action_kwargs": {
+                    "from_vessel": from_vessel,
+                    "to_vessel": to_vessel,
+                    "column": column,
+                    "rf": rf,
+                    "pct1": pct1,
+                    "pct2": pct2,
+                    "solvent1": solvent1,
+                    "solvent2": solvent2,
+                    "ratio": ratio
+                }
             }
-        }
-        action_sequence.append(column_separation_action)
-        
-        # 等待柱层析设备完成分离
-        action_sequence.append({
-            "action_name": "wait",
-            "action_kwargs": {"time": 60}
-        })
-    
-    # === 第三步：从柱子转移到目标容器（如果需要） ===
-    if column in G.nodes() and column != to_vessel:
-        print(f"RUN_COLUMN: 产物转移 - 从 {column} 到 {to_vessel}")
-        
-        try:
-            product_transfer_actions = generate_pump_protocol(
-                G=G,
-                from_vessel=column,
-                to_vessel=to_vessel,
-                volume=source_volume * 0.8 if source_volume > 0 else 80.0,  # 假设有一些损失
-                flowrate=1.5
-            )
-            action_sequence.extend(product_transfer_actions)
-        except Exception as e:
-            print(f"RUN_COLUMN: 产物转移失败: {str(e)}")
-    
-    print(f"RUN_COLUMN: 生成了 {len(action_sequence)} 个动作")
-    return action_sequence
-
-
-# 便捷函数：常用柱层析方案
-def generate_flash_column_protocol(
-    G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column_material: str = "silica_gel",
-    mobile_phase: str = "ethyl_acetate",
-    mobile_phase_volume: float = 100.0
-) -> List[Dict[str, Any]]:
-    """快速柱层析：高流速分离"""
-    return generate_run_column_protocol(
-        G, from_vessel, to_vessel, column_material, 
-        mobile_phase, mobile_phase_volume, 1, "", 0.0, 3.0
-    )
-
-
-def generate_preparative_column_protocol(
-    G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column_material: str = "silica_gel",
-    equilibration_solvent: str = "hexane",
-    eluting_solvent: str = "ethyl_acetate",
-    eluting_volume: float = 50.0,
-    eluting_repeats: int = 3
-) -> List[Dict[str, Any]]:
-    """制备柱层析：带平衡和多次洗脱"""
-    return generate_run_column_protocol(
-        G, from_vessel, to_vessel, column_material,
-        eluting_solvent, eluting_volume, eluting_repeats,
-        equilibration_solvent, 30.0, 1.5
-    )
-
-
-def generate_gradient_column_protocol(
-    G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column_material: str = "silica_gel",
-    gradient_solvents: List[str] = None,
-    gradient_volumes: List[float] = None
-) -> List[Dict[str, Any]]:
-    """梯度洗脱柱层析：多种溶剂系统"""
-    if gradient_solvents is None:
-        gradient_solvents = ["hexane", "ethyl_acetate", "methanol"]
-    if gradient_volumes is None:
-        gradient_volumes = [50.0, 50.0, 30.0]
-    
-    action_sequence = []
-    
-    # 每种溶剂单独执行一次柱层析
-    for i, (solvent, volume) in enumerate(zip(gradient_solvents, gradient_volumes)):
-        print(f"RUN_COLUMN: 梯度洗脱第 {i+1}/{len(gradient_solvents)} 步: {volume} mL {solvent}")
-        
-        # 第一步使用源容器，后续步骤使用柱子作为源
-        step_from_vessel = from_vessel if i == 0 else column_material
-        # 最后一步使用目标容器，其他步骤使用柱子作为目标
-        step_to_vessel = to_vessel if i == len(gradient_solvents) - 1 else column_material
-        
-        step_actions = generate_run_column_protocol(
-            G, step_from_vessel, step_to_vessel, column_material,
-            solvent, volume, 1, "", 0.0, 1.0
-        )
-        action_sequence.extend(step_actions)
-        
-        # 在梯度步骤之间加入等待时间
-        if i < len(gradient_solvents) - 1:
+            action_sequence.append(column_separation_action)
+            debug_print(f"✅ 柱层析设备动作已添加")
+            
+            # 等待分离完成
+            separation_time = max(30, int(total_elution_volume / 2))  # 基于体积估算时间
             action_sequence.append({
                 "action_name": "wait",
-                "action_kwargs": {"time": 20}
+                "action_kwargs": {"time": separation_time}
             })
+            debug_print(f"✅ 等待分离完成: {separation_time}秒")
+        
+        # 步骤6.5: 产物收集（从柱容器到目标容器）
+        if column_vessel and column_vessel != to_vessel:
+            debug_print(f"6.5: 产物收集 - 从 {column_vessel} 到 {to_vessel}")
+            
+            try:
+                # 估算产物体积（原始样品体积的70-90%）
+                product_volume = source_volume * 0.8
+                
+                product_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=column_vessel,
+                    to_vessel=to_vessel,
+                    volume=product_volume,
+                    flowrate=1.5,
+                    transfer_flowrate=0.8
+                )
+                action_sequence.extend(product_transfer_actions)
+                debug_print(f"✅ 产物收集完成，添加了 {len(product_transfer_actions)} 个动作")
+            except Exception as e:
+                debug_print(f"⚠️ 产物收集失败: {str(e)}")
+        
+        # 步骤6.6: 如果没有独立的柱设备和容器，执行简化的直接转移
+        if not column_device_id and not column_vessel:
+            debug_print(f"6.6: 简化模式 - 直接转移 {source_volume}mL 从 {from_vessel} 到 {to_vessel}")
+            
+            try:
+                direct_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=from_vessel,
+                    to_vessel=to_vessel,
+                    volume=source_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(direct_transfer_actions)
+                debug_print(f"✅ 直接转移完成，添加了 {len(direct_transfer_actions)} 个动作")
+            except Exception as e:
+                debug_print(f"⚠️ 直接转移失败: {str(e)}")
+        
+    except Exception as e:
+        debug_print(f"❌ 协议生成失败: {str(e)} 😭")
+        
+        # 不添加不确定的动作，直接让action_sequence保持为空列表
+        # action_sequence 已经在函数开始时初始化为 []
+    
+    # 确保至少有一个有效的动作，如果完全失败就返回空列表
+    if not action_sequence:
+        debug_print("⚠️ 没有生成任何有效动作")
+        # 可以选择返回空列表或添加一个基本的等待动作
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 1.0,
+                "description": "柱层析协议执行完成"
+            }
+        })
+    
+    # 🎊 总结
+    debug_print("🧪" * 20)
+    debug_print(f"🎉 柱层析协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 路径: {from_vessel} → {to_vessel}")
+    debug_print(f"🏛️ 柱子: {column}")
+    debug_print(f"🧪 溶剂: {final_solvent1}:{final_solvent2}")
+    debug_print("🧪" * 20)
     
     return action_sequence
 
-
-def generate_reverse_phase_column_protocol(
-    G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column_material: str = "C18",
-    aqueous_phase: str = "water",
-    organic_phase: str = "methanol",
-    gradient_ratio: float = 0.5
-) -> List[Dict[str, Any]]:
-    """反相柱层析：C18柱，水-有机相梯度"""
-    # 先用水相平衡
-    equilibration_volume = 20.0
-    # 然后用有机相洗脱
-    eluting_volume = 30.0 * gradient_ratio
-    
-    return generate_run_column_protocol(
-        G, from_vessel, to_vessel, column_material,
-        organic_phase, eluting_volume, 2,
-        aqueous_phase, equilibration_volume, 0.8
-    )
-
-
-def generate_ion_exchange_column_protocol(
-    G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column_material: str = "ion_exchange",
-    buffer_solution: str = "buffer",
-    salt_solution: str = "NaCl_solution",
-    salt_volume: float = 40.0
-) -> List[Dict[str, Any]]:
-    """离子交换柱层析：缓冲液平衡，盐溶液洗脱"""
-    return generate_run_column_protocol(
-        G, from_vessel, to_vessel, column_material,
-        salt_solution, salt_volume, 1,
-        buffer_solution, 25.0, 0.5
-    )
-
-
 # 测试函数
 def test_run_column_protocol():
-    """测试柱层析协议的示例"""
-    print("=== RUN COLUMN PROTOCOL 测试 ===")
-    print("测试完成")
-
+    """测试柱层析协议"""
+    debug_print("🧪 === RUN COLUMN PROTOCOL 测试 === ✨")
+    debug_print("✅ 测试完成 🎉")
 
 if __name__ == "__main__":
-    test_run_column_protocol()
+    test_run_column_protocol()
+

unilabos/compile/separate_protocol.py

@@ -1,230 +1,670 @@
-import numpy as np
 import networkx as nx
+import re
+import logging
+import sys
+from typing import List, Dict, Any, Union
+from .pump_protocol import generate_pump_protocol_with_rinsing
 
+logger = logging.getLogger(__name__)
+
+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        print(f"[分离协议] {safe_message}", flush=True)
+        logger.info(f"[分离协议] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        print(f"[分离协议] {safe_message}", flush=True)
+        logger.info(f"[分离协议] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        print(f"[分离协议] {fallback_message}", flush=True)
+        logger.info(f"[分离协议] {fallback_message}")
+
+def create_action_log(message: str, emoji: str = "📝") -> Dict[str, Any]:
+    """创建一个动作日志 - 支持中文和emoji"""
+    try:
+        full_message = f"{emoji} {message}"
+        debug_print(full_message)
+        logger.info(full_message)
+        
+        return {
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": full_message,
+                "progress_message": full_message
+            }
+        }
+    except Exception as e:
+        # 如果emoji有问题，使用纯文本
+        safe_message = f"[日志] {message}"
+        debug_print(safe_message)
+        logger.info(safe_message)
+        
+        return {
+            "action_name": "wait", 
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": safe_message,
+                "progress_message": safe_message
+            }
+        }
+
+def parse_volume_input(volume_input: Union[str, float]) -> float:
+    """
+    解析体积输入，支持带单位的字符串
+    
+    Args:
+        volume_input: 体积输入（如 "200 mL", "?", 50.0）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if isinstance(volume_input, (int, float)):
+        debug_print(f"📏 体积输入为数值: {volume_input}")
+        return float(volume_input)
+    
+    if not volume_input or not str(volume_input).strip():
+        debug_print(f"⚠️ 体积输入为空，返回 0.0mL")
+        return 0.0
+    
+    volume_str = str(volume_input).lower().strip()
+    debug_print(f"🔍 解析体积输入: '{volume_str}'")
+    
+    # 处理未知体积
+    if volume_str in ['?', 'unknown', 'tbd', 'to be determined', '未知', '待定']:
+        default_volume = 100.0  # 默认100mL
+        debug_print(f"❓ 检测到未知体积，使用默认值: {default_volume}mL")
+        return default_volume
+    
+    # 移除空格并提取数字和单位
+    volume_clean = re.sub(r'\s+', '', volume_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(ml|l|μl|ul|microliter|milliliter|liter|毫升|升|微升)?', volume_clean)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析体积: '{volume_str}'，使用默认值 100mL")
+        return 100.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or 'ml'  # 默认单位为毫升
+    
+    # 转换为毫升
+    if unit in ['l', 'liter', '升']:
+        volume = value * 1000.0  # L -> mL
+        debug_print(f"🔄 体积转换: {value}L -> {volume}mL")
+    elif unit in ['μl', 'ul', 'microliter', '微升']:
+        volume = value / 1000.0  # μL -> mL
+        debug_print(f"🔄 体积转换: {value}μL -> {volume}mL")
+    else:  # ml, milliliter, 毫升 或默认
+        volume = value  # 已经是mL
+        debug_print(f"✅ 体积已为毫升单位: {volume}mL")
+    
+    return volume
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂容器，支持多种匹配模式"""
+    if not solvent or not solvent.strip():
+        debug_print("⏭️ 未指定溶剂，跳过溶剂容器查找")
+        return ""
+    
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器...")
+    
+    # 🔧 方法1：直接搜索 data.reagent_name 和 config.reagent
+    debug_print(f"📋 方法1: 搜索试剂字段...")
+    for node in G.nodes():
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        config_data = G.nodes[node].get('config', {})
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            config_reagent = config_data.get('reagent', '').lower()
+            
+            # 精确匹配
+            if reagent_name == solvent.lower() or config_reagent == solvent.lower():
+                debug_print(f"✅ 通过试剂字段精确匹配找到容器: {node}")
+                return node
+            
+            # 模糊匹配
+            if (solvent.lower() in reagent_name and reagent_name) or \
+               (solvent.lower() in config_reagent and config_reagent):
+                debug_print(f"✅ 通过试剂字段模糊匹配找到容器: {node}")
+                return node
+    
+    # 🔧 方法2：常见的容器命名规则
+    debug_print(f"📋 方法2: 使用命名规则...")
+    solvent_clean = solvent.lower().replace(' ', '_').replace('-', '_')
+    possible_names = [
+        f"flask_{solvent_clean}",
+        f"bottle_{solvent_clean}",
+        f"vessel_{solvent_clean}",
+        f"{solvent_clean}_flask",
+        f"{solvent_clean}_bottle",
+        f"solvent_{solvent_clean}",
+        f"reagent_{solvent_clean}",
+        f"reagent_bottle_{solvent_clean}",
+        f"reagent_bottle_1",  # 通用试剂瓶
+        f"reagent_bottle_2",
+        f"reagent_bottle_3"
+    ]
+    
+    debug_print(f"🎯 尝试的容器名称: {possible_names[:5]}... (共 {len(possible_names)} 个)")
+    
+    for name in possible_names:
+        if name in G.nodes():
+            node_type = G.nodes[name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"✅ 通过命名规则找到容器: {name}")
+                return name
+    
+    # 🔧 方法3：使用第一个试剂瓶作为备选
+    debug_print(f"📋 方法3: 查找备用试剂瓶...")
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        if (node_data.get('type') == 'container' and 
+            ('reagent' in node_id.lower() or 'bottle' in node_id.lower())):
+            debug_print(f"⚠️ 未找到专用容器，使用备用容器: {node_id}")
+            return node_id
+    
+    debug_print(f"❌ 无法找到溶剂 '{solvent}' 的容器")
+    return ""
+
+def find_separator_device(G: nx.DiGraph, vessel: str) -> str:
+    """查找分离器设备，支持多种查找方式"""
+    debug_print(f"🔍 正在查找容器 '{vessel}' 的分离器设备...")
+    
+    # 方法1：查找连接到容器的分离器设备
+    debug_print(f"📋 方法1: 检查连接的分离器...")
+    separator_nodes = []
+    for node in G.nodes():
+        node_class = G.nodes[node].get('class', '').lower()
+        if 'separator' in node_class:
+            separator_nodes.append(node)
+            debug_print(f"📋 发现分离器设备: {node}")
+            
+            # 检查是否连接到目标容器
+            if G.has_edge(node, vessel) or G.has_edge(vessel, node):
+                debug_print(f"✅ 找到连接的分离器: {node}")
+                return node
+    
+    debug_print(f"📊 找到的分离器总数: {len(separator_nodes)}")
+    
+    # 方法2：根据命名规则查找
+    debug_print(f"📋 方法2: 使用命名规则...")
+    possible_names = [
+        f"{vessel}_controller",
+        f"{vessel}_separator",
+        vessel,  # 容器本身可能就是分离器
+        "separator_1",
+        "virtual_separator",
+        "liquid_handler_1",  # 液体处理器也可能用于分离
+        "controller_1"
+    ]
+    
+    debug_print(f"🎯 尝试的分离器名称: {possible_names}")
+    
+    for name in possible_names:
+        if name in G.nodes():
+            node_class = G.nodes[name].get('class', '').lower()
+            if 'separator' in node_class or 'controller' in node_class:
+                debug_print(f"✅ 通过命名规则找到分离器: {name}")
+                return name
+    
+    # 方法3：查找第一个分离器设备
+    debug_print(f"📋 方法3: 使用第一个可用分离器...")
+    if separator_nodes:
+        debug_print(f"⚠️ 使用第一个分离器设备: {separator_nodes[0]}")
+        return separator_nodes[0]
+    
+    debug_print(f"❌ 未找到分离器设备")
+    return ""
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
+    """查找连接到指定容器的搅拌器"""
+    debug_print(f"🔍 正在查找与容器 {vessel} 连接的搅拌器...")
+    
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'stirrer' in node_class.lower():
+            stirrer_nodes.append(node)
+            debug_print(f"📋 发现搅拌器: {node}")
+    
+    debug_print(f"📊 找到的搅拌器总数: {len(stirrer_nodes)}")
+    
+    # 检查哪个搅拌器与目标容器相连
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer}")
+            return stirrer
+    
+    # 如果没有连接的搅拌器，返回第一个可用的
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个可用的: {stirrer_nodes[0]}")
+        return stirrer_nodes[0]
+    
+    debug_print("❌ 未找到搅拌器")
+    return ""
 
 def generate_separate_protocol(
-    G: nx.DiGraph, 
-    purpose: str,  # 'wash' or 'extract'. 'wash' means that product phase will not be the added solvent phase, 'extract' means product phase will be the added solvent phase. If no solvent is added just use 'extract'.
-    product_phase: str, # 'top' or 'bottom'. Phase that product will be in.
-    from_vessel: str, #Contents of from_vessel are transferred to separation_vessel and separation is performed.
-    separation_vessel: str, # Vessel in which separation of phases will be carried out.
-    to_vessel: str, # Vessel to send product phase to.
-    waste_phase_to_vessel: str, # Optional. Vessel to send waste phase to.
-    solvent: str, # Optional. Solvent to add to separation vessel after contents of from_vessel has been transferred to create two phases.
-    solvent_volume: float = 50, # Optional. Volume of solvent to add (mL).
-    through: str = "", # Optional. Solid chemical to send product phase through on way to to_vessel, e.g. 'celite'.
-    repeats: int = 1, # Optional. Number of separations to perform.
-    stir_time: float = 30, # Optional. Time stir for after adding solvent, before separation of phases.
-    stir_speed: float = 300, # Optional. Speed to stir at after adding solvent, before separation of phases.
-    settling_time: float = 300 # Optional. Time
-) -> list[dict]:
+    G: nx.DiGraph,
+    # 🔧 基础参数，支持XDL的vessel参数
+    vessel: str = "",                    # XDL: 分离容器
+    purpose: str = "separate",           # 分离目的
+    product_phase: str = "top",          # 产物相
+    # 🔧 可选的详细参数
+    from_vessel: str = "",               # 源容器（通常在separate前已经transfer了）
+    separation_vessel: str = "",         # 分离容器（与vessel同义）
+    to_vessel: str = "",                 # 目标容器（可选）
+    waste_phase_to_vessel: str = "",     # 废相目标容器
+    product_vessel: str = "",            # XDL: 产物容器（与to_vessel同义）
+    waste_vessel: str = "",              # XDL: 废液容器（与waste_phase_to_vessel同义）
+    # 🔧 溶剂相关参数
+    solvent: str = "",                   # 溶剂名称
+    solvent_volume: Union[str, float] = 0.0,  # 溶剂体积
+    volume: Union[str, float] = 0.0,     # XDL: 体积（与solvent_volume同义）
+    # 🔧 操作参数
+    through: str = "",                   # 通过材料
+    repeats: int = 1,                    # 重复次数
+    stir_time: float = 30.0,             # 搅拌时间（秒）
+    stir_speed: float = 300.0,           # 搅拌速度
+    settling_time: float = 300.0,        # 沉降时间（秒）
+    **kwargs
+) -> List[Dict[str, Any]]:
     """
-    Generate a protocol to clean a vessel with a solvent.
+    生成分离操作的协议序列 - 增强中文版
     
-    :param G: Directed graph. Nodes are containers and pumps, edges are fluidic connections.
-    :param vessel: Vessel to clean.
-    :param solvent: Solvent to clean vessel with.
-    :param volume: Volume of solvent to clean vessel with.
-    :param temp: Temperature to heat vessel to while cleaning.
-    :param repeats: Number of cleaning cycles to perform.
-    :return: List of actions to clean vessel.
+    支持XDL参数格式：
+    - vessel: 分离容器（必需）
+    - purpose: "wash", "extract", "separate"
+    - product_phase: "top", "bottom"
+    - product_vessel: 产物收集容器
+    - waste_vessel: 废液收集容器
+    - solvent: 溶剂名称
+    - volume: "200 mL", "?" 或数值
+    - repeats: 重复次数
+    
+    分离流程：
+    1. （可选）添加溶剂到分离容器
+    2. 搅拌混合
+    3. 静置分层
+    4. 收集指定相到目标容器
+    5. 重复指定次数
     """
     
-    # 生成泵操作的动作序列
-    pump_action_sequence = []
-    reactor_volume = 500.0
-    waste_vessel = waste_phase_to_vessel
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成分离协议 - 增强中文版")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 容器: '{vessel}'")
+    debug_print(f"  🎯 分离目的: '{purpose}'")
+    debug_print(f"  📊 产物相: '{product_phase}'")
+    debug_print(f"  💧 溶剂: '{solvent}'")
+    debug_print(f"  📏 体积: {volume} (类型: {type(volume)})")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    debug_print(f"  🎯 产物容器: '{product_vessel}'")
+    debug_print(f"  🗑️ 废液容器: '{waste_vessel}'")
+    debug_print(f"  📦 其他参数: {kwargs}")
+    debug_print("=" * 60)
     
-    # TODO：通过物料管理系统找到溶剂的容器
-    if "," in solvent:
-        solvents = solvent.split(",")
-        assert len(solvents) == repeats, "Number of solvents must match number of repeats."
+    action_sequence = []
+    
+    # === 参数验证和标准化 ===
+    debug_print("🔍 步骤1: 参数验证和标准化...")
+    action_sequence.append(create_action_log(f"开始分离操作 - 容器: {vessel}", "🎬"))
+    action_sequence.append(create_action_log(f"分离目的: {purpose}", "🧪"))
+    action_sequence.append(create_action_log(f"产物相: {product_phase}", "📊"))
+    
+    # 统一容器参数
+    final_vessel = vessel or separation_vessel
+    if not final_vessel:
+        debug_print("❌ 必须指定分离容器")
+        raise ValueError("必须指定分离容器 (vessel 或 separation_vessel)")
+    
+    final_to_vessel = to_vessel or product_vessel
+    final_waste_vessel = waste_phase_to_vessel or waste_vessel
+    
+    # 统一体积参数
+    final_volume = parse_volume_input(volume or solvent_volume)
+    
+    # 🔧 修复：确保repeats至少为1
+    if repeats <= 0:
+        repeats = 1
+        debug_print(f"⚠️ 重复次数参数 <= 0，自动设置为 1")
+    
+    debug_print(f"🔧 标准化后的参数:")
+    debug_print(f"  🥼 分离容器: '{final_vessel}'")
+    debug_print(f"  🎯 产物容器: '{final_to_vessel}'")
+    debug_print(f"  🗑️ 废液容器: '{final_waste_vessel}'")
+    debug_print(f"  📏 溶剂体积: {final_volume}mL")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    
+    action_sequence.append(create_action_log(f"分离容器: {final_vessel}", "🧪"))
+    action_sequence.append(create_action_log(f"溶剂体积: {final_volume}mL", "📏"))
+    action_sequence.append(create_action_log(f"重复次数: {repeats}", "🔄"))
+    
+    # 验证必需参数
+    if not purpose:
+        purpose = "separate"
+    if not product_phase:
+        product_phase = "top"
+    if purpose not in ["wash", "extract", "separate"]:
+        debug_print(f"⚠️ 未知的分离目的 '{purpose}'，使用默认值 'separate'")
+        purpose = "separate"
+        action_sequence.append(create_action_log(f"未知目的，使用: {purpose}", "⚠️"))
+    if product_phase not in ["top", "bottom"]:
+        debug_print(f"⚠️ 未知的产物相 '{product_phase}'，使用默认值 'top'")
+        product_phase = "top"
+        action_sequence.append(create_action_log(f"未知相别，使用: {product_phase}", "⚠️"))
+    
+    debug_print("✅ 参数验证通过")
+    action_sequence.append(create_action_log("参数验证通过", "✅"))
+    
+    # === 查找设备 ===
+    debug_print("🔍 步骤2: 查找设备...")
+    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))
+    
+    # 查找分离器设备
+    separator_device = find_separator_device(G, final_vessel)
+    if separator_device:
+        action_sequence.append(create_action_log(f"找到分离器设备: {separator_device}", "🧪"))
     else:
-        solvents = [solvent] * repeats
+        debug_print("⚠️ 未找到分离器设备，可能无法执行分离")
+        action_sequence.append(create_action_log("未找到分离器设备", "⚠️"))
     
-    # TODO: 通过设备连接图找到分离容器的控制器、底部出口
-    separator_controller = f"{separation_vessel}_controller"
-    separation_vessel_bottom = f"flask_{separation_vessel}"
+    # 查找搅拌器
+    stirrer_device = find_connected_stirrer(G, final_vessel)
+    if stirrer_device:
+        action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_device}", "🌪️"))
+    else:
+        action_sequence.append(create_action_log("未找到搅拌器", "⚠️"))
     
-    transfer_flowrate = flowrate = 2.5
+    # 查找溶剂容器（如果需要）
+    solvent_vessel = ""
+    if solvent and solvent.strip():
+        solvent_vessel = find_solvent_vessel(G, solvent)
+        if solvent_vessel:
+            action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "💧"))
+        else:
+            action_sequence.append(create_action_log(f"未找到溶剂容器: {solvent}", "⚠️"))
     
-    if from_vessel != separation_vessel:
-        pump_action_sequence.append(
-            {
-                "device_id": "", 
-                "action_name": "PumpTransferProtocol",
-                "action_kwargs": {
-                    "from_vessel": from_vessel,
-                    "to_vessel": separation_vessel,
-                    "volume": reactor_volume,
-                    "time": reactor_volume / flowrate,
-                    # "transfer_flowrate": transfer_flowrate,
+    debug_print(f"📊 设备配置:")
+    debug_print(f"  🧪 分离器设备: '{separator_device}'")
+    debug_print(f"  🌪️ 搅拌器设备: '{stirrer_device}'")
+    debug_print(f"  💧 溶剂容器: '{solvent_vessel}'")
+    
+    # === 执行分离流程 ===
+    debug_print("🔍 步骤3: 执行分离流程...")
+    action_sequence.append(create_action_log("开始分离工作流程", "🎯"))
+    
+    try:
+        for repeat_idx in range(repeats):
+            cycle_num = repeat_idx + 1
+            debug_print(f"🔄 第{cycle_num}轮: 开始分离循环 {cycle_num}/{repeats}")
+            action_sequence.append(create_action_log(f"分离循环 {cycle_num}/{repeats} 开始", "🔄"))
+            
+            # 步骤3.1: 添加溶剂（如果需要）
+            if solvent_vessel and final_volume > 0:
+                debug_print(f"🔄 第{cycle_num}轮 步骤1: 添加溶剂 {solvent} ({final_volume}mL)")
+                action_sequence.append(create_action_log(f"向分离容器添加 {final_volume}mL {solvent}", "💧"))
+                
+                try:
+                    # 使用pump protocol添加溶剂
+                    pump_actions = generate_pump_protocol_with_rinsing(
+                        G=G,
+                        from_vessel=solvent_vessel,
+                        to_vessel=final_vessel,
+                        volume=final_volume,
+                        amount="",
+                        time=0.0,
+                        viscous=False,
+                        rinsing_solvent="",
+                        rinsing_volume=0.0,
+                        rinsing_repeats=0,
+                        solid=False,
+                        flowrate=2.5,
+                        transfer_flowrate=0.5,
+                        rate_spec="",
+                        event="",
+                        through="",
+                        **kwargs
+                    )
+                    action_sequence.extend(pump_actions)
+                    debug_print(f"✅ 溶剂添加完成，添加了 {len(pump_actions)} 个动作")
+                    action_sequence.append(create_action_log(f"溶剂转移完成 ({len(pump_actions)} 个操作)", "✅"))
+                    
+                except Exception as e:
+                    debug_print(f"❌ 溶剂添加失败: {str(e)}")
+                    action_sequence.append(create_action_log(f"溶剂添加失败: {str(e)}", "❌"))
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤1: 无需添加溶剂")
+                action_sequence.append(create_action_log("无需添加溶剂", "⏭️"))
+            
+            # 步骤3.2: 启动搅拌（如果有搅拌器）
+            if stirrer_device and stir_time > 0:
+                debug_print(f"🔄 第{cycle_num}轮 步骤2: 开始搅拌 ({stir_speed}rpm，持续 {stir_time}s)")
+                action_sequence.append(create_action_log(f"开始搅拌: {stir_speed}rpm，持续 {stir_time}s", "🌪️"))
+                
+                action_sequence.append({
+                    "device_id": stirrer_device,
+                    "action_name": "start_stir",
+                    "action_kwargs": {
+                        "vessel": final_vessel,
+                        "stir_speed": stir_speed,
+                        "purpose": f"分离混合 - {purpose}"
+                    }
+                })
+                
+                # 搅拌等待
+                stir_minutes = stir_time / 60
+                action_sequence.append(create_action_log(f"搅拌中，持续 {stir_minutes:.1f} 分钟", "⏱️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": stir_time}
+                })
+                
+                # 停止搅拌
+                action_sequence.append(create_action_log("停止搅拌器", "🛑"))
+                action_sequence.append({
+                    "device_id": stirrer_device,
+                    "action_name": "stop_stir",
+                    "action_kwargs": {"vessel": final_vessel}
+                })
+                
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤2: 无需搅拌")
+                action_sequence.append(create_action_log("无需搅拌", "⏭️"))
+            
+            # 步骤3.3: 静置分层
+            if settling_time > 0:
+                debug_print(f"🔄 第{cycle_num}轮 步骤3: 静置分层 ({settling_time}s)")
+                settling_minutes = settling_time / 60
+                action_sequence.append(create_action_log(f"静置分层 ({settling_minutes:.1f} 分钟)", "⚖️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": settling_time}
+                })
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤3: 未指定静置时间")
+                action_sequence.append(create_action_log("未指定静置时间", "⏭️"))
+            
+            # 步骤3.4: 执行分离操作
+            if separator_device:
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 执行分离操作")
+                action_sequence.append(create_action_log(f"执行分离: 收集{product_phase}相", "🧪"))
+                
+                # 调用分离器设备的separate方法
+                separate_action = {
+                    "device_id": separator_device,
+                    "action_name": "separate",
+                    "action_kwargs": {
+                        "purpose": purpose,
+                        "product_phase": product_phase,
+                        "from_vessel": from_vessel or final_vessel,
+                        "separation_vessel": final_vessel,
+                        "to_vessel": final_to_vessel or final_vessel,
+                        "waste_phase_to_vessel": final_waste_vessel or final_vessel,
+                        "solvent": solvent,
+                        "solvent_volume": final_volume,
+                        "through": through,
+                        "repeats": 1,  # 每次调用只做一次分离
+                        "stir_time": 0,  # 已经在上面完成
+                        "stir_speed": stir_speed,
+                        "settling_time": 0  # 已经在上面完成
+                    }
                 }
+                action_sequence.append(separate_action)
+                debug_print(f"✅ 分离操作已添加")
+                action_sequence.append(create_action_log("分离操作完成", "✅"))
+                
+                # 收集结果
+                if final_to_vessel:
+                    action_sequence.append(create_action_log(f"产物 ({product_phase}相) 收集到: {final_to_vessel}", "📦"))
+                if final_waste_vessel:
+                    action_sequence.append(create_action_log(f"废相收集到: {final_waste_vessel}", "🗑️"))
+            
+            else:
+                debug_print(f"🔄 第{cycle_num}轮 步骤4: 无分离器设备，跳过分离")
+                action_sequence.append(create_action_log("无分离器设备可用", "❌"))
+                # 添加等待时间模拟分离
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": 10.0}
+                })
+            
+            # 循环间等待（除了最后一次）
+            if repeat_idx < repeats - 1:
+                debug_print(f"🔄 第{cycle_num}轮: 等待下一次循环...")
+                action_sequence.append(create_action_log("等待下一次循环...", "⏳"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": 5}
+                })
+            else:
+                action_sequence.append(create_action_log(f"分离循环 {cycle_num}/{repeats} 完成", "🌟"))
+    
+    except Exception as e:
+        debug_print(f"❌ 分离工作流程执行失败: {str(e)}")
+        action_sequence.append(create_action_log(f"分离工作流程失败: {str(e)}", "❌"))
+        # 添加错误日志
+        action_sequence.append({
+            "device_id": "system",
+            "action_name": "log_message",
+            "action_kwargs": {
+                "message": f"分离操作失败: {str(e)}"
             }
-        )
-        
-        # for i in range(2):
-        #     pump_action_sequence.append(
-        #         {
-        #             "device_id": "", 
-        #             "action_name": "CleanProtocol",
-        #             "action_kwargs": {
-        #                 "vessel": from_vessel,
-        #                 "solvent": "H2O", # Solvent to clean vessel with.
-        #                 "volume": solvent_volume, # Optional. Volume of solvent to clean vessel with.
-        #                 "temp": 25.0, # Optional. Temperature to heat vessel to while cleaning.
-        #                 "repeats": 1
-        #             }
-        #         }
-        #     )
-        #     pump_action_sequence.append(
-        #         {
-        #             "device_id": "", 
-        #             "action_name": "CleanProtocol",
-        #             "action_kwargs": {
-        #                 "vessel": from_vessel,
-        #                 "solvent": "CH2Cl2", # Solvent to clean vessel with.
-        #                 "volume": solvent_volume, # Optional. Volume of solvent to clean vessel with.
-        #                 "temp": 25.0, # Optional. Temperature to heat vessel to while cleaning.
-        #                 "repeats": 1
-        #             }
-        #         }
-        #     )
+        })
     
-    # 生成泵操作的动作序列
-    for i in range(repeats):
-        # 找到当次萃取所用溶剂
-        solvent_thistime = solvents[i]
-        solvent_vessel = f"flask_{solvent_thistime}"
-        
-        pump_action_sequence.append(
-            {
-                "device_id": "", 
-                "action_name": "PumpTransferProtocol",
-                "action_kwargs": {
-                    "from_vessel": solvent_vessel,
-                    "to_vessel": separation_vessel,
-                    "volume": solvent_volume,
-                    "time": solvent_volume / flowrate,
-                    # "transfer_flowrate": transfer_flowrate,
-                }
-            }
-        )
-        pump_action_sequence.extend([
-            # 搅拌、静置
-            {
-                "device_id": separator_controller, 
-                "action_name": "stir",
-                "action_kwargs": {
-                    "stir_time": stir_time,
-                    "stir_speed": stir_speed,
-                    "settling_time": settling_time
-                }
-            },
-            # 分液（判断电导突跃）
-            {
-                "device_id": separator_controller, 
-                "action_name": "valve_open",
-                "action_kwargs": {
-                    "command": "delta > 0.05"
-                }
-            }
-        ])
-        
-        if product_phase == "bottom":
-            # 产物转移到目标瓶
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": to_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-            # 放出上面那一相，60秒后关阀门
-            pump_action_sequence.append(
-                {
-                    "device_id": separator_controller, 
-                    "action_name": "valve_open",
-                    "action_kwargs": {
-                        "command": "time > 60"
-                    }
-                }
-            )
-            # 弃去上面那一相进废液
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": waste_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-        elif product_phase == "top":
-            # 弃去下面那一相进废液
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": waste_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-            # 放出上面那一相
-            pump_action_sequence.append(
-                {
-                    "device_id": separator_controller, 
-                    "action_name": "valve_open",
-                    "action_kwargs": {
-                        "command": "time > 60"
-                    }
-                }
-            )
-            # 产物转移到目标瓶
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": separation_vessel_bottom,
-                        "to_vessel": to_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-        elif product_phase == "organic":
-            pass
-        
-        # 如果不是最后一次，从中转瓶转移回分液漏斗
-        if i < repeats - 1:
-            pump_action_sequence.append(
-                {
-                    "device_id": "", 
-                    "action_name": "PumpTransferProtocol",
-                    "action_kwargs": {
-                        "from_vessel": to_vessel,
-                        "to_vessel": separation_vessel,
-                        "volume": 250.0,
-                        "time": 250.0 / flowrate,
-                        # "transfer_flowrate": transfer_flowrate,
-                    }
-                }
-            )
-    return pump_action_sequence
+    # === 最终结果 ===
+    total_time = (stir_time + settling_time + 15) * repeats  # 估算总时间
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 分离协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f} 分钟)")
+    debug_print(f"  🥼 分离容器: {final_vessel}")
+    debug_print(f"  🎯 分离目的: {purpose}")
+    debug_print(f"  📊 产物相: {product_phase}")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    if solvent:
+        debug_print(f"  💧 溶剂: {solvent} ({final_volume}mL)")
+    if final_to_vessel:
+        debug_print(f"  🎯 产物容器: {final_to_vessel}")
+    if final_waste_vessel:
+        debug_print(f"  🗑️ 废液容器: {final_waste_vessel}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"分离协议完成: {final_vessel} ({purpose}，{repeats} 次循环)"
+    if solvent:
+        summary_msg += f"，使用 {final_volume}mL {solvent}"
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+
+# === 便捷函数 ===
+
+def separate_phases_only(G: nx.DiGraph, vessel: str, product_phase: str = "top", 
+                        product_vessel: str = "", waste_vessel: str = "") -> List[Dict[str, Any]]:
+    """仅进行相分离（不添加溶剂）"""
+    debug_print(f"⚡ 快速相分离: {vessel} ({product_phase}相)")
+    return generate_separate_protocol(
+        G, vessel=vessel, 
+        purpose="separate", 
+        product_phase=product_phase,
+        product_vessel=product_vessel,
+        waste_vessel=waste_vessel
+    )
+
+def wash_with_solvent(G: nx.DiGraph, vessel: str, solvent: str, volume: Union[str, float],
+                     product_phase: str = "top", repeats: int = 1) -> List[Dict[str, Any]]:
+    """用溶剂洗涤"""
+    debug_print(f"🧽 用{solvent}洗涤: {vessel} ({repeats} 次)")
+    return generate_separate_protocol(
+        G, vessel=vessel,
+        purpose="wash",
+        product_phase=product_phase,
+        solvent=solvent,
+        volume=volume,
+        repeats=repeats
+    )
+
+def extract_with_solvent(G: nx.DiGraph, vessel: str, solvent: str, volume: Union[str, float],
+                        product_phase: str = "bottom", repeats: int = 3) -> List[Dict[str, Any]]:
+    """用溶剂萃取"""
+    debug_print(f"🧪 用{solvent}萃取: {vessel} ({repeats} 次)")
+    return generate_separate_protocol(
+        G, vessel=vessel,
+        purpose="extract",
+        product_phase=product_phase,
+        solvent=solvent,
+        volume=volume,
+        repeats=repeats
+    )
+
+def separate_aqueous_organic(G: nx.DiGraph, vessel: str, organic_phase: str = "top",
+                            product_vessel: str = "", waste_vessel: str = "") -> List[Dict[str, Any]]:
+    """水-有机相分离"""
+    debug_print(f"💧 水-有机相分离: {vessel} (有机相: {organic_phase})")
+    return generate_separate_protocol(
+        G, vessel=vessel,
+        purpose="separate",
+        product_phase=organic_phase,
+        product_vessel=product_vessel,
+        waste_vessel=waste_vessel
+    )
+
+# 测试函数
+def test_separate_protocol():
+    """测试分离协议的各种参数解析"""
+    debug_print("=== 分离协议增强中文版测试 ===")
+    
+    # 测试体积解析
+    debug_print("🧪 测试体积解析...")
+    volumes = ["200 mL", "?", 100.0, "1 L", "500 μL", "未知", "50毫升"]
+    for vol in volumes:
+        result = parse_volume_input(vol)
+        debug_print(f"📊 体积解析结果: {vol} -> {result}mL")
+    
+    debug_print("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_separate_protocol()

unilabos/compile/stir_protocol.py

@@ -1,166 +1,342 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🌪️ [STIR] {message}", flush=True)
+    logger.info(f"[STIR] {message}")
+
+def parse_time_input(time_input: Union[str, float, int], default_unit: str = "s") -> float:
+    """
+    统一的时间解析函数（精简版）
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+        default_unit: 默认单位（默认为秒）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 100.0  # 默认100秒
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"🔍 解析时间: '{time_str}'")
+    
+    # ❓ 特殊值处理
+    special_times = {
+        '?': 300.0, 'unknown': 300.0, 'tbd': 300.0,
+        'briefly': 30.0, 'quickly': 60.0, 'slowly': 600.0,
+        'several minutes': 300.0, 'few minutes': 180.0, 'overnight': 3600.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s ({result/60:.1f}分钟)")
+        return result
+    
+    # 🔢 纯数字处理
+    try:
+        result = float(time_str)
+        debug_print(f"⏰ 纯数字: {time_str} → {result}s")
+        return result
+    except ValueError:
+        pass
+    
+    # 📐 正则表达式解析
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 100s")
+        return 100.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit
+    
+    # 📏 单位转换
+    unit_multipliers = {
+        's': 1.0, 'sec': 1.0, 'second': 1.0, 'seconds': 1.0,
+        'm': 60.0, 'min': 60.0, 'mins': 60.0, 'minute': 60.0, 'minutes': 60.0,
+        'h': 3600.0, 'hr': 3600.0, 'hrs': 3600.0, 'hour': 3600.0, 'hours': 3600.0,
+        'd': 86400.0, 'day': 86400.0, 'days': 86400.0
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"✅ 时间解析: '{time_str}' → {value} {unit} → {result}s ({result/60:.1f}分钟)")
+    return result
 
 def find_connected_stirrer(G: nx.DiGraph, vessel: str = None) -> str:
-    """
-    查找与指定容器相连的搅拌设备，或查找可用的搅拌设备
-    """
-    # 查找所有搅拌设备节点
-    stirrer_nodes = [node for node in G.nodes() 
-                    if (G.nodes[node].get('class') or '') == 'virtual_stirrer']
+    """查找与指定容器相连的搅拌设备"""
+    debug_print(f"🔍 查找搅拌设备，目标容器: {vessel} 🥽")
     
-    if vessel:
-        # 检查哪个搅拌设备与目标容器相连（机械连接）
+    # 🔧 查找所有搅拌设备
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'stirrer' in node_class.lower() or 'virtual_stirrer' in node_class:
+            stirrer_nodes.append(node)
+            debug_print(f"🎉 找到搅拌设备: {node} 🌪️")
+    
+    # 🔗 检查连接
+    if vessel and stirrer_nodes:
         for stirrer in stirrer_nodes:
             if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+                debug_print(f"✅ 搅拌设备 '{stirrer}' 与容器 '{vessel}' 相连 🔗")
                 return stirrer
     
-    # 如果没有指定容器或没有直接连接，返回第一个可用的搅拌设备
+    # 🎯 使用第一个可用设备
     if stirrer_nodes:
-        return stirrer_nodes[0]
+        selected = stirrer_nodes[0]
+        debug_print(f"🔧 使用第一个搅拌设备: {selected} 🌪️")
+        return selected
     
-    raise ValueError("系统中未找到可用的搅拌设备")
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到搅拌设备，使用默认设备 🌪️")
+    return "stirrer_1"
 
+def validate_and_fix_params(stir_time: float, stir_speed: float, settling_time: float) -> tuple:
+    """验证和修正参数"""
+    # ⏰ 搅拌时间验证
+    if stir_time < 0:
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 无效，修正为 100s 🕐")
+        stir_time = 100.0
+    elif stir_time > 100:  # 限制为100s
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 过长，仿真运行时，修正为 100s 🕐")
+        stir_time = 100.0
+    else:
+        debug_print(f"✅ 搅拌时间 {stir_time}s ({stir_time/60:.1f}分钟) 有效 ⏰")
+    
+    # 🌪️ 搅拌速度验证
+    if stir_speed < 10.0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM 🌪️")
+        stir_speed = 300.0
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
+    # ⏱️ 沉降时间验证
+    if settling_time < 0 or settling_time > 600:  # 限制为10分钟
+        debug_print(f"⚠️ 沉降时间 {settling_time}s 超出范围，修正为 60s ⏱️")
+        settling_time = 60.0
+    else:
+        debug_print(f"✅ 沉降时间 {settling_time}s 在正常范围内 ⏱️")
+    
+    return stir_time, stir_speed, settling_time
 
 def generate_stir_protocol(
     G: nx.DiGraph,
-    stir_time: float,
-    stir_speed: float,
-    settling_time: float
+    vessel: str,
+    time: Union[str, float, int] = "300",
+    stir_time: Union[str, float, int] = "0",
+    time_spec: str = "",
+    event: str = "",
+    stir_speed: float = 300.0,
+    settling_time: Union[str, float] = "60",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成搅拌操作的协议序列 - 定时搅拌 + 沉降
+    生成搅拌操作的协议序列（精简版）
     """
-    action_sequence = []
     
-    print(f"STIR: 开始生成搅拌协议")
-    print(f"  - 搅拌时间: {stir_time}秒")
-    print(f"  - 搅拌速度: {stir_speed} RPM")
-    print(f"  - 沉降时间: {settling_time}秒")
+    debug_print("🌪️" * 20)
+    debug_print("🚀 开始生成搅拌协议 ✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel}")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🕐 stir_time: {stir_time}")
+    debug_print(f"  🎯 time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  ⏱️ settling_time: {settling_time}")
+    debug_print("🌪️" * 20)
     
-    # 查找搅拌设备
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel:
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    if vessel not in G.nodes():
+        debug_print(f"❌ 容器 '{vessel}' 不存在于系统中! 😞")
+        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    # 确定实际时间（优先级：time_spec > stir_time > time）
+    if time_spec:
+        parsed_time = parse_time_input(time_spec)
+        debug_print(f"🎯 使用time_spec: '{time_spec}' → {parsed_time}s")
+    elif stir_time not in ["0", 0, 0.0]:
+        parsed_time = parse_time_input(stir_time)
+        debug_print(f"🎯 使用stir_time: {stir_time} → {parsed_time}s")
+    else:
+        parsed_time = parse_time_input(time)
+        debug_print(f"🎯 使用time: {time} → {parsed_time}s")
+    
+    # 解析沉降时间
+    parsed_settling_time = parse_time_input(settling_time)
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_stir_time = parsed_time
+    original_settling_time = parsed_settling_time
+    
+    # 搅拌时间限制为60秒
+    stir_time_limit = 60.0
+    if parsed_time > stir_time_limit:
+        parsed_time = stir_time_limit
+        debug_print(f"  🎮 搅拌时间优化: {original_stir_time}s → {parsed_time}s ⚡")
+    
+    # 沉降时间限制为30秒
+    settling_time_limit = 30.0
+    if parsed_settling_time > settling_time_limit:
+        parsed_settling_time = settling_time_limit
+        debug_print(f"  🎮 沉降时间优化: {original_settling_time}s → {parsed_settling_time}s ⚡")
+    
+    # 参数修正
+    parsed_time, stir_speed, parsed_settling_time = validate_and_fix_params(
+        parsed_time, stir_speed, parsed_settling_time
+    )
+    
+    debug_print(f"🎯 最终参数: time={parsed_time}s, speed={stir_speed}RPM, settling={parsed_settling_time}s")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找搅拌设备... 🔍")
     try:
-        stirrer_id = find_connected_stirrer(G)
-        print(f"STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
+        stirrer_id = find_connected_stirrer(G, vessel)
+        debug_print(f"🎉 使用搅拌设备: {stirrer_id} ✨")
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
         raise ValueError(f"无法找到搅拌设备: {str(e)}")
     
-    # 执行搅拌操作
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成搅拌动作... 🌪️")
+    
+    action_sequence = []
     stir_action = {
         "device_id": stirrer_id,
         "action_name": "stir",
         "action_kwargs": {
-            "stir_time": stir_time,
-            "stir_speed": stir_speed,
-            "settling_time": settling_time
+            "vessel": vessel,
+            "time": str(time),  # 保持原始格式
+            "event": event,
+            "time_spec": time_spec,
+            "stir_time": float(parsed_time),  # 确保是数字
+            "stir_speed": float(stir_speed),  # 确保是数字
+            "settling_time": float(parsed_settling_time)  # 确保是数字
         }
     }
-    
     action_sequence.append(stir_action)
+    debug_print("✅ 搅拌动作已添加 🌪️✨")
+    
+    # 显示时间优化信息
+    if original_stir_time != parsed_time or original_settling_time != parsed_settling_time:
+        debug_print(f"  🎭 模拟优化说明:")
+        debug_print(f"    搅拌时间: {original_stir_time/60:.1f}分钟 → {parsed_time/60:.1f}分钟")
+        debug_print(f"    沉降时间: {original_settling_time/60:.1f}分钟 → {parsed_settling_time/60:.1f}分钟")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 搅拌协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 搅拌容器: {vessel}")
+    debug_print(f"🌪️ 搅拌参数: {stir_speed} RPM, {parsed_time}s, 沉降 {parsed_settling_time}s")
+    debug_print(f"⏱️ 预计总时间: {(parsed_time + parsed_settling_time)/60:.1f} 分钟 ⌛")
+    debug_print("🎊" * 20)
     
-    print(f"STIR: 生成了 {len(action_sequence)} 个动作")
     return action_sequence
 
-
 def generate_start_stir_protocol(
     G: nx.DiGraph,
     vessel: str,
-    stir_speed: float,
-    purpose: str
+    stir_speed: float = 300.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成开始搅拌操作的协议序列 - 持续搅拌
-    """
-    action_sequence = []
+    """生成开始搅拌操作的协议序列"""
     
-    print(f"START_STIR: 开始生成启动搅拌协议")
-    print(f"  - 容器: {vessel}")
-    print(f"  - 搅拌速度: {stir_speed} RPM")
-    print(f"  - 目的: {purpose}")
+    debug_print("🔄 开始生成启动搅拌协议 ✨")
+    debug_print(f"🥽 vessel: {vessel}, 🌪️ speed: {stir_speed} RPM")
     
-    # 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 基础验证
+    if not vessel or vessel not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    # 查找搅拌设备
-    try:
-        stirrer_id = find_connected_stirrer(G, vessel)
-        print(f"START_STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到搅拌设备: {str(e)}")
+    # 参数修正
+    if stir_speed < 10.0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度修正: {stir_speed} → 300 RPM 🌪️")
+        stir_speed = 300.0
     
-    # 执行开始搅拌操作
-    start_stir_action = {
+    # 查找设备
+    stirrer_id = find_connected_stirrer(G, vessel)
+    
+    # 生成动作
+    action_sequence = [{
         "device_id": stirrer_id,
         "action_name": "start_stir",
         "action_kwargs": {
             "vessel": vessel,
             "stir_speed": stir_speed,
-            "purpose": purpose
+            "purpose": purpose or f"启动搅拌 {stir_speed} RPM"
         }
-    }
+    }]
     
-    action_sequence.append(start_stir_action)
-    
-    print(f"START_STIR: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 启动搅拌协议生成完成 🎯")
     return action_sequence
 
-
 def generate_stop_stir_protocol(
     G: nx.DiGraph,
-    vessel: str
+    vessel: str,
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成停止搅拌操作的协议序列
-    """
-    action_sequence = []
+    """生成停止搅拌操作的协议序列"""
     
-    print(f"STOP_STIR: 开始生成停止搅拌协议")
-    print(f"  - 容器: {vessel}")
+    debug_print("🛑 开始生成停止搅拌协议 ✨")
+    debug_print(f"🥽 vessel: {vessel}")
     
-    # 验证容器存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 '{vessel}' 不存在于系统中")
+    # 基础验证
+    if not vessel or vessel not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    # 查找搅拌设备
-    try:
-        stirrer_id = find_connected_stirrer(G, vessel)
-        print(f"STOP_STIR: 找到搅拌设备: {stirrer_id}")
-    except ValueError as e:
-        raise ValueError(f"无法找到搅拌设备: {str(e)}")
+    # 查找设备
+    stirrer_id = find_connected_stirrer(G, vessel)
     
-    # 执行停止搅拌操作
-    stop_stir_action = {
+    # 生成动作
+    action_sequence = [{
         "device_id": stirrer_id,
         "action_name": "stop_stir",
         "action_kwargs": {
             "vessel": vessel
         }
-    }
+    }]
     
-    action_sequence.append(stop_stir_action)
-    
-    print(f"STOP_STIR: 生成了 {len(action_sequence)} 个动作")
+    debug_print(f"✅ 停止搅拌协议生成完成 🎯")
     return action_sequence
 
+# 测试函数
+def test_stir_protocol():
+    """测试搅拌协议"""
+    debug_print("🧪 === STIR PROTOCOL 测试 === ✨")
+    debug_print("✅ 测试完成 🎉")
 
-# 便捷函数
-def generate_fast_stir_protocol(
-    G: nx.DiGraph,
-    time: float = 300.0,
-    speed: float = 800.0,
-    settling: float = 60.0
-) -> List[Dict[str, Any]]:
-    """快速搅拌的便捷函数"""
-    return generate_stir_protocol(G, time, speed, settling)
-
-
-def generate_gentle_stir_protocol(
-    G: nx.DiGraph,
-    time: float = 600.0,
-    speed: float = 200.0,
-    settling: float = 120.0
-) -> List[Dict[str, Any]]:
-    """温和搅拌的便捷函数"""
-    return generate_stir_protocol(G, time, speed, settling)
+if __name__ == "__main__":
+    test_stir_protocol()

unilabos/compile/utils/unit_parser.py

@@ -0,0 +1,206 @@
+"""
+统一的单位解析工具模块
+支持时间、体积、质量等各种单位的解析
+"""
+
+import re
+import logging
+from typing import Union
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message, prefix="[UNIT_PARSER]"):
+    """调试输出"""
+    print(f"{prefix} {message}", flush=True)
+    logger.info(f"{prefix} {message}")
+
+def parse_time_with_units(time_input: Union[str, float, int], default_unit: str = "s") -> float:
+    """
+    解析带单位的时间输入
+    
+    Args:
+        time_input: 时间输入（如 "30 min", "1 h", "300", "?", 60.0）
+        default_unit: 默认单位（默认为秒）
+    
+    Returns:
+        float: 时间（秒）
+    """
+    if not time_input:
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"数值时间输入: {time_input} → {result}s（默认单位）")
+        return result
+    
+    # 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    debug_print(f"解析时间字符串: '{time_str}'")
+    
+    # 处理特殊值
+    if time_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_time = 300.0  # 5分钟默认值
+        debug_print(f"检测到未知时间，使用默认值: {default_time}s")
+        return default_time
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(time_str)
+        if default_unit == "s":
+            result = value
+        elif default_unit in ["min", "minute"]:
+            result = value * 60.0
+        elif default_unit in ["h", "hour"]:
+            result = value * 3600.0
+        else:
+            result = value  # 默认秒
+        debug_print(f"纯数字输入: {time_str} → {result}s（单位: {default_unit}）")
+        return result
+    except ValueError:
+        pass
+    
+    # 使用正则表达式匹配数字和单位
+    pattern = r'(\d+\.?\d*)\s*([a-z]*)'
+    match = re.match(pattern, time_str)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析时间: '{time_str}'，使用默认值: 60s")
+        return 60.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit
+    
+    # 单位转换映射
+    unit_multipliers = {
+        # 秒
+        's': 1.0,
+        'sec': 1.0,
+        'second': 1.0,
+        'seconds': 1.0,
+        
+        # 分钟
+        'm': 60.0,
+        'min': 60.0,
+        'mins': 60.0,
+        'minute': 60.0,
+        'minutes': 60.0,
+        
+        # 小时
+        'h': 3600.0,
+        'hr': 3600.0,
+        'hrs': 3600.0,
+        'hour': 3600.0,
+        'hours': 3600.0,
+        
+        # 天
+        'd': 86400.0,
+        'day': 86400.0,
+        'days': 86400.0,
+    }
+    
+    multiplier = unit_multipliers.get(unit, 1.0)
+    result = value * multiplier
+    
+    debug_print(f"时间解析: '{time_str}' → {value} {unit} → {result}s")
+    return result
+
+def parse_volume_with_units(volume_input: Union[str, float, int], default_unit: str = "mL") -> float:
+    """
+    解析带单位的体积输入
+    
+    Args:
+        volume_input: 体积输入（如 "100 mL", "2.5 L", "500", "?", 100.0）
+        default_unit: 默认单位（默认为毫升）
+    
+    Returns:
+        float: 体积（毫升）
+    """
+    if not volume_input:
+        return 0.0
+    
+    # 处理数值输入
+    if isinstance(volume_input, (int, float)):
+        result = float(volume_input)
+        debug_print(f"数值体积输入: {volume_input} → {result}mL（默认单位）")
+        return result
+    
+    # 处理字符串输入
+    volume_str = str(volume_input).lower().strip()
+    debug_print(f"解析体积字符串: '{volume_str}'")
+    
+    # 处理特殊值
+    if volume_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_volume = 50.0  # 50mL默认值
+        debug_print(f"检测到未知体积，使用默认值: {default_volume}mL")
+        return default_volume
+    
+    # 如果是纯数字，使用默认单位
+    try:
+        value = float(volume_str)
+        if default_unit.lower() in ["ml", "milliliter"]:
+            result = value
+        elif default_unit.lower() in ["l", "liter"]:
+            result = value * 1000.0
+        elif default_unit.lower() in ["μl", "ul", "microliter"]:
+            result = value / 1000.0
+        else:
+            result = value  # 默认mL
+        debug_print(f"纯数字输入: {volume_str} → {result}mL（单位: {default_unit}）")
+        return result
+    except ValueError:
+        pass
+    
+    # 移除空格并提取数字和单位
+    volume_clean = re.sub(r'\s+', '', volume_str)
+    
+    # 匹配数字和单位的正则表达式
+    match = re.match(r'([0-9]*\.?[0-9]+)\s*(ml|l|μl|ul|microliter|milliliter|liter)?', volume_clean)
+    
+    if not match:
+        debug_print(f"⚠️ 无法解析体积: '{volume_str}'，使用默认值: 50mL")
+        return 50.0
+    
+    value = float(match.group(1))
+    unit = match.group(2) or default_unit.lower()
+    
+    # 转换为毫升
+    if unit in ['l', 'liter']:
+        volume = value * 1000.0  # L -> mL
+    elif unit in ['μl', 'ul', 'microliter']:
+        volume = value / 1000.0  # μL -> mL
+    else:  # ml, milliliter 或默认
+        volume = value  # 已经是mL
+    
+    debug_print(f"体积解析: '{volume_str}' → {value} {unit} → {volume}mL")
+    return volume
+
+# 测试函数
+def test_unit_parser():
+    """测试单位解析功能"""
+    print("=== 单位解析器测试 ===")
+    
+    # 测试时间解析
+    time_tests = [
+        "30 min", "1 h", "300", "5.5 h", "?", 60.0, "2 hours", "30 s"
+    ]
+    
+    print("\n时间解析测试:")
+    for time_input in time_tests:
+        result = parse_time_with_units(time_input)
+        print(f"  {time_input} → {result}s ({result/60:.1f}min)")
+    
+    # 测试体积解析
+    volume_tests = [
+        "100 mL", "2.5 L", "500", "?", 100.0, "500 μL", "1 liter"
+    ]
+    
+    print("\n体积解析测试:")
+    for volume_input in volume_tests:
+        result = parse_volume_with_units(volume_input)
+        print(f"  {volume_input} → {result}mL")
+    
+    print("\n✅ 测试完成")
+
+if __name__ == "__main__":
+    test_unit_parser()

unilabos/compile/wash_solid_protocol.py

@@ -1,216 +1,316 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    print(f"🧼 [WASH_SOLID] {message}", flush=True)
+    logger.info(f"[WASH_SOLID] {message}")
+
+def parse_time_input(time_input: Union[str, float, int]) -> float:
+    """统一时间解析函数（精简版）"""
+    if not time_input:
+        return 0.0
+    
+    # 🔢 处理数值输入
+    if isinstance(time_input, (int, float)):
+        result = float(time_input)
+        debug_print(f"⏰ 数值时间: {time_input} → {result}s")
+        return result
+    
+    # 📝 处理字符串输入
+    time_str = str(time_input).lower().strip()
+    
+    # ❓ 特殊值快速处理
+    special_times = {
+        '?': 60.0, 'unknown': 60.0, 'briefly': 30.0, 
+        'quickly': 45.0, 'slowly': 120.0
+    }
+    
+    if time_str in special_times:
+        result = special_times[time_str]
+        debug_print(f"🎯 特殊时间: '{time_str}' → {result}s")
+        return result
+    
+    # 🔢 数字提取（简化正则）
+    try:
+        # 提取数字
+        numbers = re.findall(r'\d+\.?\d*', time_str)
+        if numbers:
+            value = float(numbers[0])
+            
+            # 简化单位判断
+            if any(unit in time_str for unit in ['min', 'm']):
+                result = value * 60.0
+            elif any(unit in time_str for unit in ['h', 'hour']):
+                result = value * 3600.0
+            else:
+                result = value  # 默认秒
+            
+            debug_print(f"✅ 时间解析: '{time_str}' → {result}s")
+            return result
+    except:
+        pass
+    
+    debug_print(f"⚠️ 时间解析失败: '{time_str}'，使用默认60s")
+    return 60.0
+
+def parse_volume_input(volume: Union[float, str], volume_spec: str = "", mass: str = "") -> float:
+    """统一体积解析函数（精简版）"""
+    debug_print(f"💧 解析体积: volume={volume}, spec='{volume_spec}', mass='{mass}'")
+    
+    # 🎯 优先级1：volume_spec（快速映射）
+    if volume_spec:
+        spec_map = {
+            'small': 20.0, 'medium': 50.0, 'large': 100.0,
+            'minimal': 10.0, 'normal': 50.0, 'generous': 150.0
+        }
+        for key, val in spec_map.items():
+            if key in volume_spec.lower():
+                debug_print(f"🎯 规格匹配: '{volume_spec}' → {val}mL")
+                return val
+    
+    # 🧮 优先级2：mass转体积（简化：1g=1mL）
+    if mass:
+        try:
+            numbers = re.findall(r'\d+\.?\d*', mass)
+            if numbers:
+                value = float(numbers[0])
+                if 'mg' in mass.lower():
+                    result = value / 1000.0
+                elif 'kg' in mass.lower():
+                    result = value * 1000.0
+                else:
+                    result = value  # 默认g
+                debug_print(f"⚖️ 质量转换: {mass} → {result}mL")
+                return result
+        except:
+            pass
+    
+    # 📦 优先级3：volume
+    if volume:
+        if isinstance(volume, (int, float)):
+            result = float(volume)
+            debug_print(f"💧 数值体积: {volume} → {result}mL")
+            return result
+        elif isinstance(volume, str):
+            try:
+                # 提取数字
+                numbers = re.findall(r'\d+\.?\d*', volume)
+                if numbers:
+                    value = float(numbers[0])
+                    # 简化单位判断
+                    if 'l' in volume.lower() and 'ml' not in volume.lower():
+                        result = value * 1000.0  # L转mL
+                    else:
+                        result = value  # 默认mL
+                    debug_print(f"💧 字符串体积: '{volume}' → {result}mL")
+                    return result
+            except:
+                pass
+    
+    # 默认值
+    debug_print(f"⚠️ 体积解析失败，使用默认50mL")
+    return 50.0
+
+def find_solvent_source(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂源（精简版）"""
+    debug_print(f"🔍 查找溶剂源: {solvent}")
+    
+    # 简化搜索列表
+    search_patterns = [
+        f"flask_{solvent}", f"bottle_{solvent}", f"reagent_{solvent}",
+        "liquid_reagent_bottle_1", "flask_1", "solvent_bottle"
+    ]
+    
+    for pattern in search_patterns:
+        if pattern in G.nodes():
+            debug_print(f"🎉 找到溶剂源: {pattern}")
+            return pattern
+    
+    debug_print(f"⚠️ 使用默认溶剂源: flask_{solvent}")
+    return f"flask_{solvent}"
+
+def find_filtrate_vessel(G: nx.DiGraph, filtrate_vessel: str = "") -> str:
+    """查找滤液容器（精简版）"""
+    debug_print(f"🔍 查找滤液容器: {filtrate_vessel}")
+    
+    # 如果指定了且存在，直接使用
+    if filtrate_vessel and filtrate_vessel in G.nodes():
+        debug_print(f"✅ 使用指定容器: {filtrate_vessel}")
+        return filtrate_vessel
+    
+    # 简化搜索列表
+    default_vessels = ["waste_workup", "filtrate_vessel", "flask_1", "collection_bottle_1"]
+    
+    for vessel in default_vessels:
+        if vessel in G.nodes():
+            debug_print(f"🎉 找到滤液容器: {vessel}")
+            return vessel
+    
+    debug_print(f"⚠️ 使用默认滤液容器: waste_workup")
+    return "waste_workup"
 
 def generate_wash_solid_protocol(
     G: nx.DiGraph,
     vessel: str,
     solvent: str,
-    volume: float,
+    volume: Union[float, str] = "50",
     filtrate_vessel: str = "",
     temp: float = 25.0,
     stir: bool = False,
     stir_speed: float = 0.0,
-    time: float = 0.0,
-    repeats: int = 1
+    time: Union[str, float] = "0",
+    repeats: int = 1,
+    volume_spec: str = "",
+    repeats_spec: str = "",
+    mass: str = "",
+    event: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成固体清洗的协议序列
-    
-    Args:
-        G: 有向图，节点为设备和容器
-        vessel: 装有固体物质的容器名称
-        solvent: 用于清洗固体的溶剂名称
-        volume: 清洗溶剂的体积
-        filtrate_vessel: 滤液要收集到的容器名称，可选参数
-        temp: 清洗时的温度，可选参数
-        stir: 是否在清洗过程中搅拌，默认为 False
-        stir_speed: 搅拌速度，可选参数
-        time: 清洗的时间，可选参数
-        repeats: 清洗操作的重复次数，默认为 1
-    
-    Returns:
-        List[Dict[str, Any]]: 固体清洗操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到必要的设备时抛出异常
-    
-    Examples:
-        wash_solid_protocol = generate_wash_solid_protocol(
-            G, "reactor", "ethanol", 100.0, "waste_flask", 60.0, True, 300.0, 600.0, 3
-        )
+    生成固体清洗协议（精简版）
     """
+    
+    debug_print("🧼" * 20)
+    debug_print("🚀 开始生成固体清洗协议 ✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel}")
+    debug_print(f"  🧪 solvent: {solvent}")
+    debug_print(f"  💧 volume: {volume}")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🔄 repeats: {repeats}")
+    debug_print("🧼" * 20)
+    
+    # 📋 快速验证
+    if not vessel or vessel not in G.nodes():
+        debug_print("❌ 容器验证失败! 😱")
+        raise ValueError("vessel 参数无效")
+    
+    if not solvent:
+        debug_print("❌ 溶剂不能为空! 😱")
+        raise ValueError("solvent 参数不能为空")
+    
+    debug_print("✅ 基础验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤1: 参数解析... ⚡")
+    final_volume = parse_volume_input(volume, volume_spec, mass)
+    final_time = parse_time_input(time)
+    
+    # 重复次数处理（简化）
+    if repeats_spec:
+        spec_map = {'few': 2, 'several': 3, 'many': 4, 'thorough': 5}
+        final_repeats = next((v for k, v in spec_map.items() if k in repeats_spec.lower()), repeats)
+    else:
+        final_repeats = max(1, min(repeats, 5))  # 限制1-5次
+    
+    # 🕐 模拟时间优化
+    debug_print("  ⏱️ 模拟时间优化...")
+    original_time = final_time
+    if final_time > 60.0:
+        final_time = 60.0  # 限制最长60秒
+        debug_print(f"  🎮 时间优化: {original_time}s → {final_time}s ⚡")
+    
+    # 参数修正
+    temp = max(25.0, min(temp, 80.0))  # 温度范围25-80°C
+    stir_speed = max(0.0, min(stir_speed, 300.0)) if stir else 0.0  # 速度范围0-300
+    
+    debug_print(f"🎯 最终参数: 体积={final_volume}mL, 时间={final_time}s, 重复={final_repeats}次")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤2: 查找设备... 🔍")
+    try:
+        solvent_source = find_solvent_source(G, solvent)
+        actual_filtrate_vessel = find_filtrate_vessel(G, filtrate_vessel)
+        debug_print(f"🎉 设备配置完成 ✨")
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"设备查找失败: {str(e)}")
+    
+    # 🚀 生成动作序列
+    debug_print("📍 步骤3: 生成清洗动作... 🧼")
     action_sequence = []
     
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"固体容器 {vessel} 不存在于图中")
-    
-    if filtrate_vessel and filtrate_vessel not in G.nodes():
-        raise ValueError(f"滤液容器 {filtrate_vessel} 不存在于图中")
-    
-    # 查找转移泵设备（用于添加溶剂和转移滤液）
-    pump_nodes = [node for node in G.nodes() 
-                  if G.nodes[node].get('class') == 'virtual_transfer_pump']
-    
-    if not pump_nodes:
-        raise ValueError("没有找到可用的转移泵设备")
-    
-    pump_id = pump_nodes[0]
-    
-    # 查找加热设备（如果需要加热）
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
-    
-    heatchill_id = heatchill_nodes[0] if heatchill_nodes else None
-    
-    # 查找搅拌设备（如果需要搅拌）
-    stirrer_nodes = [node for node in G.nodes() 
-                    if G.nodes[node].get('class') == 'virtual_stirrer']
-    
-    stirrer_id = stirrer_nodes[0] if stirrer_nodes else None
-    
-    # 查找过滤设备（用于分离固体和滤液）
-    filter_nodes = [node for node in G.nodes() 
-                   if G.nodes[node].get('class') == 'virtual_filter']
-    
-    filter_id = filter_nodes[0] if filter_nodes else None
-    
-    # 查找溶剂容器
-    solvent_vessel = f"flask_{solvent}"
-    if solvent_vessel not in G.nodes():
-        # 如果没有找到特定溶剂容器，查找可用的源容器
-        available_vessels = [node for node in G.nodes() 
-                           if node.startswith('flask_') and 
-                           G.nodes[node].get('type') == 'container']
-        if available_vessels:
-            solvent_vessel = available_vessels[0]
-        else:
-            raise ValueError(f"没有找到溶剂容器 {solvent}")
-    
-    # 如果没有指定滤液容器，使用废液容器
-    if not filtrate_vessel:
-        waste_vessels = [node for node in G.nodes() 
-                        if 'waste' in node.lower() and 
-                        G.nodes[node].get('type') == 'container']
-        filtrate_vessel = waste_vessels[0] if waste_vessels else "waste_flask"
-    
-    # 重复清洗操作
-    for repeat in range(repeats):
-        repeat_num = repeat + 1
+    for cycle in range(final_repeats):
+        debug_print(f"  🔄 第{cycle+1}/{final_repeats}次清洗...")
         
-        # 步骤1：如果需要加热，先设置温度
-        if temp > 25.0 and heatchill_id:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_start",
+        # 1. 转移溶剂
+        try:
+            from .pump_protocol import generate_pump_protocol_with_rinsing
+            
+            transfer_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=solvent_source,
+                to_vessel=vessel,
+                volume=final_volume,
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.5,
+                transfer_flowrate=0.5
+            )
+            
+            if transfer_actions:
+                action_sequence.extend(transfer_actions)
+                debug_print(f"    ✅ 转移动作: {len(transfer_actions)}个 🚚")
+            
+        except Exception as e:
+            debug_print(f"    ❌ 转移失败: {str(e)} 😞")
+        
+        # 2. 搅拌（如果需要）
+        if stir and final_time > 0:
+            stir_action = {
+                "device_id": "stirrer_1",
+                "action_name": "stir",
                 "action_kwargs": {
                     "vessel": vessel,
-                    "temp": temp,
-                    "purpose": f"固体清洗 - 第 {repeat_num} 次"
+                    "time": str(time),
+                    "stir_time": final_time,
+                    "stir_speed": stir_speed,
+                    "settling_time": 10.0  # 🕐 缩短沉降时间
                 }
-            })
-        
-        # 步骤2：添加清洗溶剂到固体容器
-        action_sequence.append({
-            "device_id": pump_id,
-            "action_name": "transfer",
-            "action_kwargs": {
-                "from_vessel": solvent_vessel,
-                "to_vessel": vessel,
-                "volume": volume,
-                "amount": f"清洗溶剂 {solvent} - 第 {repeat_num} 次",
-                "time": 0.0,
-                "viscous": False,
-                "rinsing_solvent": "",
-                "rinsing_volume": 0.0,
-                "rinsing_repeats": 0,
-                "solid": False
             }
+            action_sequence.append(stir_action)
+            debug_print(f"    ✅ 搅拌动作: {final_time}s, {stir_speed}RPM 🌪️")
+        
+        # 3. 过滤
+        filter_action = {
+            "device_id": "filter_1",
+            "action_name": "filter",
+            "action_kwargs": {
+                "vessel": vessel,
+                "filtrate_vessel": actual_filtrate_vessel,
+                "temp": temp,
+                "volume": final_volume
+            }
+        }
+        action_sequence.append(filter_action)
+        debug_print(f"    ✅ 过滤动作: → {actual_filtrate_vessel} 🌊")
+        
+        # 4. 等待（缩短时间）
+        wait_time = 5.0  # 🕐 缩短等待时间：10s → 5s
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": wait_time}
         })
-        
-        # 步骤3：如果需要搅拌，开始搅拌
-        if stir and stir_speed > 0 and stirrer_id:
-            if time > 0:
-                # 定时搅拌
-                action_sequence.append({
-                    "device_id": stirrer_id,
-                    "action_name": "stir",
-                    "action_kwargs": {
-                        "stir_time": time,
-                        "stir_speed": stir_speed,
-                        "settling_time": 30.0  # 搅拌后静置30秒
-                    }
-                })
-            else:
-                # 开始搅拌（需要手动停止）
-                action_sequence.append({
-                    "device_id": stirrer_id,
-                    "action_name": "start_stir",
-                    "action_kwargs": {
-                        "vessel": vessel,
-                        "stir_speed": stir_speed,
-                        "purpose": f"固体清洗搅拌 - 第 {repeat_num} 次"
-                    }
-                })
-        
-        # 步骤4：如果指定了清洗时间但没有搅拌，等待清洗时间
-        if time > 0 and (not stir or stir_speed == 0):
-            # 这里可以添加等待操作，暂时跳过
-            pass
-        
-        # 步骤5：如果有搅拌且没有定时，停止搅拌
-        if stir and stir_speed > 0 and time == 0 and stirrer_id:
-            action_sequence.append({
-                "device_id": stirrer_id,
-                "action_name": "stop_stir",
-                "action_kwargs": {
-                    "vessel": vessel
-                }
-            })
-        
-        # 步骤6：过滤分离固体和滤液
-        if filter_id:
-            action_sequence.append({
-                "device_id": filter_id,
-                "action_name": "filter_sample",
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "filtrate_vessel": filtrate_vessel,
-                    "stir": False,
-                    "stir_speed": 0.0,
-                    "temp": temp,
-                    "continue_heatchill": temp > 25.0,
-                    "volume": volume
-                }
-            })
-        else:
-            # 没有专门的过滤设备，使用转移泵模拟过滤过程
-            # 将滤液转移到滤液容器
-            action_sequence.append({
-                "device_id": pump_id,
-                "action_name": "transfer",
-                "action_kwargs": {
-                    "from_vessel": vessel,
-                    "to_vessel": filtrate_vessel,
-                    "volume": volume,
-                    "amount": f"转移滤液 - 第 {repeat_num} 次清洗",
-                    "time": 0.0,
-                    "viscous": False,
-                    "rinsing_solvent": "",
-                    "rinsing_volume": 0.0,
-                    "rinsing_repeats": 0,
-                    "solid": False
-                }
-            })
-        
-        # 步骤7：如果加热了，停止加热（在最后一次清洗后）
-        if temp > 25.0 and heatchill_id and repeat_num == repeats:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_stop",
-                "action_kwargs": {
-                    "vessel": vessel
-                }
-            })
+        debug_print(f"    ✅ 等待: {wait_time}s ⏰")
+    
+    # 🎊 总结
+    debug_print("🧼" * 20)
+    debug_print(f"🎉 固体清洗协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 清洗容器: {vessel}")
+    debug_print(f"🧪 使用溶剂: {solvent}")
+    debug_print(f"💧 清洗体积: {final_volume}mL × {final_repeats}次")
+    debug_print(f"⏱️ 预计总时间: {(final_time + 5) * final_repeats / 60:.1f} 分钟")
+    debug_print("🧼" * 20)
     
     return action_sequence

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -119,46 +119,114 @@ class LiquidHandlerAbstract(LiquidHandler):
             else:
                 if len(asp_vols) != len(targets):
                     raise ValueError(f"Length of `asp_vols` {len(asp_vols)} must match `targets` {len(targets)}.")
-                tip = next(self.current_tip)
-                await self.pick_up_tips(tip)
+                
+                # 首先应该对任务分组，然后每次1个/8个进行操作处理
+                if len(use_channels) == 1:
+                    tip = []
+                    for _ in range(len(use_channels)):
+                        tip.extend(next(self.current_tip))
+                    await self.pick_up_tips(tip)
 
-                for _ in range(len(targets)):
-                    await self.aspirate(
-                        resources=reagent_sources,
-                        vols=[asp_vols[_]],
-                        use_channels=use_channels,
-                        flow_rates=[flow_rates[0]] if flow_rates else None,
-                        offsets=[offsets[0]] if offsets else None,
-                        liquid_height=[liquid_height[0]] if liquid_height else None,
-                        blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume else None,
-                        spread=spread,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[0])
-                    await self.dispense(
-                        resources=[targets[_]],
-                        vols=[dis_vols[_]],
-                        use_channels=use_channels,
-                        flow_rates=[flow_rates[1]] if flow_rates else None,
-                        offsets=[offsets[1]] if offsets else None,
-                        blow_out_air_volume=[blow_out_air_volume[1]] if blow_out_air_volume else None,
-                        liquid_height=[liquid_height[1]] if liquid_height else None,
-                        spread=spread,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
-                    await self.mix(
-                        targets=targets[_],
-                        mix_time=mix_time,
-                        mix_vol=mix_vol,
-                        offsets=offsets if offsets else None,
-                        height_to_bottom=mix_liquid_height if mix_liquid_height else None,
-                        mix_rate=mix_rate if mix_rate else None,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
-                    await self.touch_tip(targets[_])
-                await self.discard_tips()
+                    for _ in range(len(targets)):
+                        await self.aspirate(
+                            resources=reagent_sources,
+                            vols=[asp_vols[_]],
+                            use_channels=use_channels,
+                            flow_rates=[flow_rates[0]] if flow_rates else None,
+                            offsets=[offsets[0]] if offsets else None,
+                            liquid_height=[liquid_height[0]] if liquid_height else None,
+                            blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume else None,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[0])
+                        await self.dispense(
+                            resources=[targets[_]],
+                            vols=[dis_vols[_]],
+                            use_channels=use_channels,
+                            flow_rates=[flow_rates[1]] if flow_rates else None,
+                            offsets=[offsets[1]] if offsets else None,
+                            blow_out_air_volume=[blow_out_air_volume[1]] if blow_out_air_volume else None,
+                            liquid_height=[liquid_height[1]] if liquid_height else None,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        await self.mix(
+                            targets=targets[_],
+                            mix_time=mix_time,
+                            mix_vol=mix_vol,
+                            offsets=offsets if offsets else None,
+                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                            mix_rate=mix_rate if mix_rate else None,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        await self.touch_tip(targets[_])
+                    await self.discard_tips()
+                elif len(use_channels) == 8:
+                    tip = []
+                    for _ in range(len(use_channels)):
+                        tip.extend(next(self.current_tip))
+                    await self.pick_up_tips(tip)
+
+                    # 对于8个的情况，需要判断此时任务是不是能被8通道移液站来成功处理
+                    if len(targets) % 8 != 0:
+                        raise ValueError(f"Length of `targets` {len(targets)} must be a multiple of 8 for 8-channel mode.")
+                    
+                    # 8个8个来取任务序列
+
+                    for i in range(0, len(targets), 8):
+                        # 取出8个任务
+                        current_targets = targets[i:i + 8]
+                        current_reagent_sources = reagent_sources[i:i + 8]
+                        current_asp_vols = asp_vols[i:i + 8]
+                        current_dis_vols = dis_vols[i:i + 8]
+                        current_asp_flow_rates = flow_rates[i:i + 8] if flow_rates else [None] * 8
+                        current_dis_flow_rates = flow_rates[i+8 :i + 16] if flow_rates else [None] * 8
+                        current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
+                        current_dis_offset = offsets[i+8 :i + 16] if offsets else [None] * 8
+                        current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                        current_dis_liquid_height = liquid_height[i+8 :i + 16] if liquid_height else [None] * 8
+                        current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                        current_dis_blow_out_air_volume = blow_out_air_volume[i+8 :i + 16] if blow_out_air_volume else [None] * 8
+                        
+                        await self.aspirate(
+                            resources=current_reagent_sources,
+                            vols=current_asp_vols,
+                            use_channels=use_channels,
+                            flow_rates=current_asp_flow_rates,
+                            offsets=current_asp_offset,
+                            liquid_height=current_asp_liquid_height,
+                            blow_out_air_volume=current_asp_blow_out_air_volume,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[0])
+                        await self.dispense(
+                            resources=current_targets,
+                            vols=current_dis_vols,
+                            use_channels=use_channels,
+                            flow_rates=current_dis_flow_rates,
+                            offsets=current_dis_offset,
+                            liquid_height=current_dis_liquid_height,
+                            blow_out_air_volume=current_dis_blow_out_air_volume,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+
+                        await self.mix(
+                            targets=current_targets,
+                            mix_time=mix_time,
+                            mix_vol=mix_vol,
+                            offsets=offsets if offsets else None,
+                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                            mix_rate=mix_rate if mix_rate else None,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        #await self.touch_tip(current_targets)
 
         except Exception as e:
             traceback.print_exc()
@@ -208,56 +276,126 @@ class LiquidHandlerAbstract(LiquidHandler):
         """
 
         try:
-            # ------------------------------------------------------------------
-            # 96‑channel head mode
-            # ------------------------------------------------------------------
             if is_96_well:
-                pass  # This mode is not verified
+                pass  # This mode is not verified.
             else:
-                if not (len(asp_vols) == len(sources) and len(dis_vols) == len(targets)):
-                    raise ValueError("`sources`, `targets`, and `vols` must have the same length.")
-
-                tip_iter = self.iter_tips(tip_racks)
-                for src, tgt, asp_vol, asp_flow_rate, dis_vol, dis_flow_rate in zip(
-                    sources, targets, asp_vols, asp_flow_rates, dis_vols, dis_flow_rates
-                ):
-                    tip = next(tip_iter)
+                if len(asp_vols) != len(targets):
+                    raise ValueError(f"Length of `asp_vols` {len(asp_vols)} must match `targets` {len(targets)}.")
+                
+                # 首先应该对任务分组，然后每次1个/8个进行操作处理
+                if len(use_channels) == 1:
+                    tip = []
+                    for _ in range(len(use_channels)):
+                        tip.extend(next(self.current_tip))
                     await self.pick_up_tips(tip)
-                    # Aspirate from source
-                    await self.aspirate(
-                        resources=[src],
-                        vols=[asp_vol],
-                        use_channels=use_channels,
-                        flow_rates=[asp_flow_rate],
-                        offsets=offsets,
-                        liquid_height=liquid_height,
-                        blow_out_air_volume=blow_out_air_volume,
-                        spread=spread,
-                    )
-                    self.custom_delay(seconds=delays[0] if delays else 0)
-                    # Dispense into target
-                    await self.dispense(
-                        resources=[tgt],
-                        vols=[dis_vol],
-                        use_channels=use_channels,
-                        flow_rates=[dis_flow_rate],
-                        offsets=offsets,
-                        liquid_height=liquid_height,
-                        blow_out_air_volume=blow_out_air_volume,
-                        spread=spread,
-                    )
-                    await self.mix(
-                        targets=[tgt],
-                        mix_time=mix_times[0] if mix_times else None,
-                        mix_vol=mix_vol[0] if mix_vol else None,
-                        mix_rate=mix_rate[0] if mix_rate else None,
-                    )
-                    if touch_tip:
-                        await self.touch_tip(tgt)
+
+                    for _ in range(len(targets)):
+                        await self.aspirate(
+                            resources=sources,
+                            vols=[asp_vols[_]],
+                            use_channels=use_channels,
+                            flow_rates=[asp_flow_rates[0]] if asp_flow_rates else None,
+                            offsets=[offsets[0]] if offsets else None,
+                            liquid_height=[liquid_height[0]] if liquid_height else None,
+                            blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume else None,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[0])
+                        await self.dispense(
+                            resources=[targets[_]],
+                            vols=[dis_vols[_]],
+                            use_channels=use_channels,
+                            flow_rates=[dis_flow_rates[1]] if dis_flow_rates else None,
+                            offsets=[offsets[1]] if offsets else None,
+                            blow_out_air_volume=[blow_out_air_volume[1]] if blow_out_air_volume else None,
+                            liquid_height=[liquid_height[1]] if liquid_height else None,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        await self.mix(
+                            targets=targets[_],
+                            mix_time=mix_times,
+                            mix_vol=mix_vol,
+                            offsets=offsets if offsets else None,
+                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                            mix_rate=mix_rate if mix_rate else None,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        await self.touch_tip(targets[_])
                     await self.discard_tips()
 
-        except Exception as exc:
-            raise RuntimeError(f"Liquid transfer failed: {exc}") from exc
+                elif len(use_channels) == 8:
+                    tip = []
+                    for _ in range(len(use_channels)):
+                        tip.extend(next(self.current_tip))
+                    await self.pick_up_tips(tip)
+
+                    # 对于8个的情况，需要判断此时任务是不是能被8通道移液站来成功处理
+                    if len(targets) % 8 != 0:
+                        raise ValueError(f"Length of `targets` {len(targets)} must be a multiple of 8 for 8-channel mode.")
+                    
+                    # 8个8个来取任务序列
+
+                    for i in range(0, len(targets), 8):
+                        # 取出8个任务
+                        current_targets = targets[i:i + 8]
+                        current_reagent_sources = sources[i:i + 8]
+                        current_asp_vols = asp_vols[i:i + 8]
+                        current_dis_vols = dis_vols[i:i + 8]
+                        current_asp_flow_rates = asp_flow_rates[i:i + 8] 
+                        current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
+                        current_dis_offset = offsets[i+8 :i + 16] if offsets else [None] * 8
+                        current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                        current_dis_liquid_height = liquid_height[i+8 :i + 16] if liquid_height else [None] * 8
+                        current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                        current_dis_blow_out_air_volume = blow_out_air_volume[i+8 :i + 16] if blow_out_air_volume else [None] * 8
+                        current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else [None] * 8
+
+                        await self.aspirate(
+                            resources=current_reagent_sources,
+                            vols=current_asp_vols,
+                            use_channels=use_channels,
+                            flow_rates=current_asp_flow_rates,
+                            offsets=current_asp_offset,
+                            blow_out_air_volume=current_asp_blow_out_air_volume,
+                            liquid_height=current_asp_liquid_height,
+                            spread=spread,
+                        )
+                        
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[0])
+                        await self.dispense(
+                            resources=current_targets,
+                            vols=current_dis_vols,
+                            use_channels=use_channels,
+                            flow_rates=current_dis_flow_rates,
+                            offsets=current_dis_offset,
+                            blow_out_air_volume=current_dis_blow_out_air_volume,
+                            liquid_height=current_dis_liquid_height,
+                            spread=spread,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+
+                        await self.mix(
+                            targets=current_targets,
+                            mix_time=mix_times,
+                            mix_vol=mix_vol,
+                            offsets=offsets if offsets else None,
+                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                            mix_rate=mix_rate if mix_rate else None,
+                        )
+                        if delays is not None:
+                            await self.custom_delay(seconds=delays[1])
+                        
+                        #await self.touch_tip(current_targets)
+        except Exception as e:
+            traceback.print_exc()
+            raise RuntimeError(f"Liquid addition failed: {e}") from e
+
 
     # ---------------------------------------------------------------
     # Helper utilities
@@ -339,6 +477,7 @@ class LiquidHandlerAbstract(LiquidHandler):
 
     def set_tiprack(self, tip_racks: Sequence[TipRack]):
         """Set the tip racks for the liquid handler."""
+
         self.tip_racks = tip_racks
         tip_iter = self.iter_tips(tip_racks)
         self.current_tip = tip_iter

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -91,10 +91,11 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
     @property
     def reset_ok(self) -> bool:
         """检查设备是否已重置成功。"""
+        if self._unilabos_backend.debug:
+            return True
         return self._unilabos_backend.is_reset_ok
 
-
-    def __init__(self, deck: Deck, host: str, port: int, timeout: float, setup=True):
+    def __init__(self, deck: Deck, host: str, port: int, timeout: float, setup=True, debug=False):
         tablets_info = []
         count = 0
         for child in deck.children:
@@ -103,7 +104,7 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
                 tablets_info.append(
                     WorkTablets(Number=count, Code=f"T{count}", Material=child._unilabos_state["Material"])
                 )
-        self._unilabos_backend = PRCXI9300Backend(tablets_info, host, port, timeout, setup)
+        self._unilabos_backend = PRCXI9300Backend(tablets_info, host, port, timeout, setup, debug)
         super().__init__(backend=self._unilabos_backend, deck=deck)
 
     async def create_protocol(
@@ -329,13 +330,15 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         port: int = 9999,
         timeout: float = 10.0,
         setup=True,
+        debug=False,
     ) -> None:
         super().__init__()
         self.tablets_info = tablets_info
-        self.api_client = PRCXI9300Api(host, port, timeout)
+        self.api_client = PRCXI9300Api(host, port, timeout, debug)
         self.host, self.port, self.timeout = host, port, timeout
         self._num_channels = 8
         self._execute_setup = setup
+        self.debug = debug
 
     def create_protocol(self, protocol_name):
         self.protocol_name = protocol_name
@@ -389,7 +392,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
     async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int] = None):
         """Pick up tips from the specified resource."""
-
+       
         if len(ops) != 8:
             raise ValueError(f"PRCXI9300Backend pick_up_tips: Expected 8 pickups, got {len(ops)}")
 
@@ -427,7 +430,6 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         )
         self.steps_todo_list.append(step)
 
-
     async def drop_tips(self, ops: List[Drop], use_channels: List[int] = None):
 
         """Pick up tips from the specified resource."""
@@ -566,6 +568,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
             hole_numbers="1,2,3,4,5,6,7,8",
         )
         self.steps_todo_list.append(step)
+        
 
 
     async def dispense(self, ops: List[SingleChannelDispense], use_channels: List[int] = None):
@@ -648,14 +651,17 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
 
 class PRCXI9300Api:
-    def __init__(self, host: str = "127.0.0.1", port: int = 9999, timeout: float = 10.0) -> None:
+    def __init__(self, host: str = "127.0.0.1", port: int = 9999, timeout: float = 10.0, debug: bool = False) -> None:
         self.host, self.port, self.timeout = host, port, timeout
+        self.debug = debug
 
     @staticmethod
     def _len_prefix(n: int) -> bytes:
         return bytes.fromhex(format(n, "016x"))
 
     def _raw_request(self, payload: str) -> str:
+        if self.debug:
+            return " "
         with contextlib.closing(socket.socket()) as sock:
             sock.settimeout(self.timeout)
             sock.connect((self.host, self.port))
@@ -1017,30 +1023,55 @@ if __name__ == "__main__":
     deck.assign_child_resource(plate5, location=Coordinate(0, 0, 0))
     deck.assign_child_resource(plate6, location=Coordinate(0, 0, 0))
 
-    handler = PRCXI9300Handler(deck=deck, host="192.168.3.9", port=9999, timeout=10.0, setup=False)
+    handler = PRCXI9300Handler(deck=deck, host="192.168.3.9", port=9999, timeout=10.0, setup=False, debug=True)
     handler.set_tiprack([tip_rack])  # Set the tip rack for the handler
     asyncio.run(handler.setup())  # Initialize the handler and setup the connection
     asyncio.run(handler.create_protocol(protocol_name="Test Protocol"))  # Initialize the backend and setup the connection
-    asyncio.run(handler.pick_up_tips(tip_rack.children[:8],[0,1,2,3,4,5,6,7]))
-    asyncio.run(handler.aspirate(well_containers.children[:8],[50]*8, [0,1,2,3,4,5,6,7]))
-    asyncio.run(handler.dispense(well_containers.children[:8],[50]*8,[0,1,2,3,4,5,6,7]))
-    asyncio.run(handler.drop_tips(tip_rack.children[8:16],[0,1,2,3,4,5,6,7]))
-    asyncio.run(handler.mix(well_containers.children[:8], mix_time=3, mix_vol=50, height_to_bottom=0.5, offsets=Coordinate(0, 0, 0), mix_rate=100))
-    print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
-    # asyncio.run(handler.add_liquid(
-    #     asp_vols=[100]*8,
-    #     dis_vols=[100]*8,
-    #     reagent_sources=well_containers.children[-8:],
-    #     targets=well_containers.children[:8],
+    # asyncio.run(handler.pick_up_tips(tip_rack.children[:8],[0,1,2,3,4,5,6,7]))
+    # asyncio.run(handler.aspirate(well_containers.children[:8],[50]*8, [0,1,2,3,4,5,6,7]))
+    # asyncio.run(handler.dispense(well_containers.children[:8],[50]*8,[0,1,2,3,4,5,6,7]))
+    # asyncio.run(handler.drop_tips(tip_rack.children[8:16],[0,1,2,3,4,5,6,7]))
+    # asyncio.run(handler.mix(well_containers.children[:8], mix_time=3, mix_vol=50, height_to_bottom=0.5, offsets=Coordinate(0, 0, 0), mix_rate=100))
+    #print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
+    asyncio.run(handler.add_liquid(
+        asp_vols=[100]*16,
+        dis_vols=[100]*16,
+        reagent_sources=well_containers.children[-16:],
+        targets=well_containers.children[:16],
+        use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
+        flow_rates=[None] * 16,
+        offsets=[Coordinate(0, 0, 0)] * 16,
+        liquid_height=[None] * 16,
+        blow_out_air_volume=[None] * 16,
+        delays=None,
+        mix_time=3,
+        mix_vol=50,
+        spread="wide",
+    ))
+
+    # asyncio.run(handler.transfer_liquid(
+    #     asp_vols=[100]*16,
+    #     dis_vols=[100]*16,
+    #     tip_racks=[tip_rack],
+    #     sources=well_containers.children[-16:],
+    #     targets=well_containers.children[:16],
     #     use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
-    #     flow_rates=[None] * 8,
-    #     offsets=[Coordinate(0, 0, 0)] * 8,
-    #     liquid_height=[None] * 8,
-    #     blow_out_air_volume=[None] * 8,
+    #     offsets=[Coordinate(0, 0, 0)] * 32,
+    #     asp_flow_rates=[None] * 16,
+    #     dis_flow_rates=[None] * 16,
+    #     liquid_height=[None] * 32,
+    #     blow_out_air_volume=[None] * 32,
+    #     mix_times=3,
+    #     mix_vol=50,
     #     spread="wide",
     # ))
+    print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
     # input("pick_up_tips add step")
-    asyncio.run(handler.run_protocol())  # Run the protocol
+    #asyncio.run(handler.run_protocol())  # Run the protocol
     # input("Running protocol...")
     # input("Press Enter to continue...")  # Wait for user input before proceeding
     # print("PRCXI9300Handler initialized with deck and host settings.")
+
+
+
+# 但是怎么丢tip？这个需要手动设置一下？

unilabos/devices/virtual/virtual_column.py

@@ -3,7 +3,7 @@ import logging
 from typing import Dict, Any, Optional
 
 class VirtualColumn:
-    """Virtual column device for RunColumn protocol"""
+    """Virtual column device for RunColumn protocol 🏛️"""
     
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -25,45 +25,77 @@ class VirtualColumn:
         self._column_length = self.config.get('column_length') or kwargs.get('column_length', 25.0)
         self._column_diameter = self.config.get('column_diameter') or kwargs.get('column_diameter', 2.0)
         
-        print(f"=== VirtualColumn {self.device_id} created with max_flow_rate={self._max_flow_rate}, length={self._column_length}cm ===")
+        print(f"🏛️ === 虚拟色谱柱 {self.device_id} 已创建 === ✨")
+        print(f"📏 柱参数: 流速={self._max_flow_rate}mL/min | 长度={self._column_length}cm | 直径={self._column_diameter}cm 🔬")
     
     async def initialize(self) -> bool:
-        """Initialize virtual column"""
-        self.logger.info(f"Initializing virtual column {self.device_id}")
+        """Initialize virtual column 🚀"""
+        self.logger.info(f"🔧 初始化虚拟色谱柱 {self.device_id} ✨")
+        
         self.data.update({
             "status": "Idle",
-            "column_state": "Ready",
+            "column_state": "Ready", 
             "current_flow_rate": 0.0,
             "max_flow_rate": self._max_flow_rate,
             "column_length": self._column_length,
             "column_diameter": self._column_diameter,
             "processed_volume": 0.0,
             "progress": 0.0,
-            "current_status": "Ready"
+            "current_status": "Ready for separation"
         })
+        
+        self.logger.info(f"✅ 色谱柱 {self.device_id} 初始化完成 🏛️")
+        self.logger.info(f"📊 设备规格: 最大流速 {self._max_flow_rate}mL/min | 柱长 {self._column_length}cm 📏")
         return True
     
     async def cleanup(self) -> bool:
-        """Cleanup virtual column"""
-        self.logger.info(f"Cleaning up virtual column {self.device_id}")
+        """Cleanup virtual column 🧹"""
+        self.logger.info(f"🧹 清理虚拟色谱柱 {self.device_id} 🔚")
+        
+        self.data.update({
+            "status": "Offline",
+            "column_state": "Offline",
+            "current_status": "System offline"
+        })
+        
+        self.logger.info(f"✅ 色谱柱 {self.device_id} 清理完成 💤")
         return True
     
-    async def run_column(self, from_vessel: str, to_vessel: str, column: str) -> bool:
-        """Execute column chromatography run - matches RunColumn action"""
-        self.logger.info(f"Running column separation: {from_vessel} -> {to_vessel} using {column}")
+    async def run_column(self, from_vessel: str, to_vessel: str, column: str, **kwargs) -> bool:
+        """Execute column chromatography run - matches RunColumn action 🏛️"""
+        
+        # 提取额外参数
+        rf = kwargs.get('rf', '0.3')
+        solvent1 = kwargs.get('solvent1', 'ethyl_acetate')
+        solvent2 = kwargs.get('solvent2', 'hexane')
+        ratio = kwargs.get('ratio', '30:70')
+        
+        self.logger.info(f"🏛️ 开始柱层析分离: {from_vessel} → {to_vessel} 🚰")
+        self.logger.info(f"  🧪 使用色谱柱: {column}")
+        self.logger.info(f"  🎯 Rf值: {rf}")
+        self.logger.info(f"  🧪 洗脱溶剂: {solvent1}:{solvent2} ({ratio}) 💧")
         
         # 更新设备状态
         self.data.update({
             "status": "Running",
             "column_state": "Separating",
-            "current_status": "Column separation in progress",
+            "current_status": "🏛️ Column separation in progress",
             "progress": 0.0,
-            "processed_volume": 0.0
+            "processed_volume": 0.0,
+            "current_from_vessel": from_vessel,
+            "current_to_vessel": to_vessel,
+            "current_column": column,
+            "current_rf": rf,
+            "current_solvents": f"{solvent1}:{solvent2} ({ratio})"
         })
         
         # 模拟柱层析分离过程
         # 假设处理时间基于流速和柱子长度
-        separation_time = (self._column_length * 2) / self._max_flow_rate  # 简化计算
+        base_time = (self._column_length * 2) / self._max_flow_rate  # 简化计算
+        separation_time = max(base_time, 20.0)  # 最少20秒
+        
+        self.logger.info(f"⏱️ 预计分离时间: {separation_time:.1f}秒 ⌛")
+        self.logger.info(f"📏 柱参数: 长度 {self._column_length}cm | 流速 {self._max_flow_rate}mL/min 🌊")
         
         steps = 20  # 分20个步骤模拟分离过程
         step_time = separation_time / steps
@@ -74,34 +106,65 @@ class VirtualColumn:
             progress = (i + 1) / steps * 100
             volume_processed = (i + 1) * 5.0  # 假设每步处理5mL
             
+            # 不同阶段的状态描述
+            if progress <= 25:
+                phase = "🌊 样品上柱阶段"
+                phase_emoji = "📥"
+            elif progress <= 50:
+                phase = "🧪 洗脱开始"
+                phase_emoji = "💧"
+            elif progress <= 75:
+                phase = "⚗️ 成分分离中"
+                phase_emoji = "🔄"
+            else:
+                phase = "🎯 收集产物"
+                phase_emoji = "📤"
+            
             # 更新状态
+            status_msg = f"{phase_emoji} {phase}: {progress:.1f}% | 💧 已处理: {volume_processed:.1f}mL"
+            
             self.data.update({
                 "progress": progress,
                 "processed_volume": volume_processed,
-                "current_status": f"Column separation: {progress:.1f}% - Processing {volume_processed:.1f}mL"
+                "current_status": status_msg,
+                "current_phase": phase
             })
             
-            self.logger.info(f"Column separation progress: {progress:.1f}%")
+            # 进度日志（每25%打印一次）
+            if progress >= 25 and (i + 1) % 5 == 0:  # 每5步（25%）打印一次
+                self.logger.info(f"📊 分离进度: {progress:.0f}% | {phase} | 💧 {volume_processed:.1f}mL 完成 ✨")
         
         # 分离完成
+        final_status = f"✅ 柱层析分离完成: {from_vessel} → {to_vessel} | 💧 共处理 {volume_processed:.1f}mL"
+        
         self.data.update({
             "status": "Idle",
             "column_state": "Ready",
-            "current_status": "Column separation completed",
-            "progress": 100.0
+            "current_status": final_status,
+            "progress": 100.0,
+            "final_volume": volume_processed
         })
         
-        self.logger.info(f"Column separation completed: {from_vessel} -> {to_vessel}")
+        self.logger.info(f"🎉 柱层析分离完成! ✨")
+        self.logger.info(f"📊 分离结果:")
+        self.logger.info(f"  🥽 源容器: {from_vessel}")
+        self.logger.info(f"  🥽 目标容器: {to_vessel}")
+        self.logger.info(f"  🏛️ 使用色谱柱: {column}")
+        self.logger.info(f"  💧 处理体积: {volume_processed:.1f}mL")
+        self.logger.info(f"  🧪 洗脱条件: {solvent1}:{solvent2} ({ratio})")
+        self.logger.info(f"  🎯 Rf值: {rf}")
+        self.logger.info(f"  ⏱️ 总耗时: {separation_time:.1f}秒 🏁")
+        
         return True
     
     # 状态属性
     @property
     def status(self) -> str:
-        return self.data.get("status", "Unknown")
+        return self.data.get("status", "❓ Unknown")
     
     @property
     def column_state(self) -> str:
-        return self.data.get("column_state", "Unknown")
+        return self.data.get("column_state", "❓ Unknown")
     
     @property
     def current_flow_rate(self) -> float:
@@ -129,4 +192,12 @@ class VirtualColumn:
     
     @property
     def current_status(self) -> str:
-        return self.data.get("current_status", "Ready")
+        return self.data.get("current_status", "📋 Ready")
+    
+    @property
+    def current_phase(self) -> str:
+        return self.data.get("current_phase", "🏠 待机中")
+    
+    @property
+    def final_volume(self) -> float:
+        return self.data.get("final_volume", 0.0)

unilabos/devices/virtual/virtual_filter.py

@@ -5,7 +5,7 @@ from typing import Dict, Any, Optional
 
 
 class VirtualFilter:
-    """Virtual filter device - 完全按照 Filter.action 规范"""
+    """Virtual filter device - 完全按照 Filter.action 规范 🌊"""
     
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         if device_id is None and 'id' in kwargs:
@@ -31,8 +31,8 @@ class VirtualFilter:
                 setattr(self, key, value)
     
     async def initialize(self) -> bool:
-        """Initialize virtual filter"""
-        self.logger.info(f"Initializing virtual filter {self.device_id}")
+        """Initialize virtual filter 🚀"""
+        self.logger.info(f"🔧 初始化虚拟过滤器 {self.device_id} ✨")
         
         # 按照 Filter.action 的 feedback 字段初始化
         self.data.update({
@@ -43,17 +43,21 @@ class VirtualFilter:
             "current_status": "Ready for filtration",  # Filter.action feedback
             "message": "Ready for filtration"
         })
+        
+        self.logger.info(f"✅ 过滤器 {self.device_id} 初始化完成 🌊")
         return True
     
     async def cleanup(self) -> bool:
-        """Cleanup virtual filter"""
-        self.logger.info(f"Cleaning up virtual filter {self.device_id}")
+        """Cleanup virtual filter 🧹"""
+        self.logger.info(f"🧹 清理虚拟过滤器 {self.device_id} 🔚")
         
         self.data.update({
             "status": "Offline",
             "current_status": "System offline",
             "message": "System offline"
         })
+        
+        self.logger.info(f"✅ 过滤器 {self.device_id} 清理完成 💤")
         return True
     
     async def filter(
@@ -66,64 +70,82 @@ class VirtualFilter:
         continue_heatchill: bool = False, 
         volume: float = 0.0
     ) -> bool:
-        """Execute filter action - 完全按照 Filter.action 参数"""
-        self.logger.info(f"Filter: vessel={vessel}, filtrate_vessel={filtrate_vessel}")
-        self.logger.info(f"  stir={stir}, stir_speed={stir_speed}, temp={temp}")
-        self.logger.info(f"  continue_heatchill={continue_heatchill}, volume={volume}")
+        """Execute filter action - 完全按照 Filter.action 参数 🌊"""
+        
+        # 🔧 新增：温度自动调整
+        original_temp = temp
+        if temp == 0.0:
+            temp = 25.0  # 0度自动设置为室温
+            self.logger.info(f"🌡️ 温度自动调整: {original_temp}°C → {temp}°C (室温) 🏠")
+        elif temp < 4.0:
+            temp = 4.0   # 小于4度自动设置为4度
+            self.logger.info(f"🌡️ 温度自动调整: {original_temp}°C → {temp}°C (最低温度) ❄️")
+        
+        self.logger.info(f"🌊 开始过滤操作: {vessel} → {filtrate_vessel} 🚰")
+        self.logger.info(f"  🌪️ 搅拌: {stir} ({stir_speed} RPM)")
+        self.logger.info(f"  🌡️ 温度: {temp}°C")
+        self.logger.info(f"  💧 体积: {volume}mL")
+        self.logger.info(f"  🔥 保持加热: {continue_heatchill}")
         
         # 验证参数
         if temp > self._max_temp or temp < 4.0:
-            error_msg = f"温度 {temp}°C 超出范围 (4-{self._max_temp}°C)"
-            self.logger.error(error_msg)
+            error_msg = f"🌡️ 温度 {temp}°C 超出范围 (4-{self._max_temp}°C) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
-                "current_status": f"Error: {error_msg}",
+                "status": f"Error: 温度超出范围 ⚠️",
+                "current_status": f"Error: 温度超出范围 ⚠️",
                 "message": error_msg
             })
             return False
         
         if stir and stir_speed > self._max_stir_speed:
-            error_msg = f"搅拌速度 {stir_speed} RPM 超出范围 (0-{self._max_stir_speed} RPM)"
-            self.logger.error(error_msg)
+            error_msg = f"🌪️ 搅拌速度 {stir_speed} RPM 超出范围 (0-{self._max_stir_speed} RPM) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
-                "current_status": f"Error: {error_msg}",
+                "status": f"Error: 搅拌速度超出范围 ⚠️",
+                "current_status": f"Error: 搅拌速度超出范围 ⚠️",
                 "message": error_msg
             })
             return False
         
         if volume > self._max_volume:
-            error_msg = f"过滤体积 {volume} mL 超出范围 (0-{self._max_volume} mL)"
-            self.logger.error(error_msg)
+            error_msg = f"💧 过滤体积 {volume} mL 超出范围 (0-{self._max_volume} mL) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
-                "current_status": f"Error: {error_msg}",
+                "status": f"Error: 体积超出范围 ⚠️",
+                "current_status": f"Error: 体积超出范围 ⚠️",
                 "message": error_msg
             })
             return False
         
         # 开始过滤
         filter_volume = volume if volume > 0 else 50.0
+        self.logger.info(f"🚀 开始过滤 {filter_volume}mL 液体 💧")
         
         self.data.update({
-            "status": f"过滤中: {vessel}",
+            "status": f"🌊 过滤中: {vessel}",
             "current_temp": temp,
             "filtered_volume": 0.0,
             "progress": 0.0,
-            "current_status": f"Filtering {vessel} → {filtrate_vessel}",
-            "message": f"Starting filtration: {vessel} → {filtrate_vessel}"
+            "current_status": f"🌊 Filtering {vessel} → {filtrate_vessel}",
+            "message": f"🚀 Starting filtration: {vessel} → {filtrate_vessel}"
         })
         
         try:
             # 过滤过程 - 实时更新进度
             start_time = time_module.time()
+            
             # 根据体积和搅拌估算过滤时间
             base_time = filter_volume / 5.0  # 5mL/s 基础速度
             if stir:
                 base_time *= 0.8  # 搅拌加速过滤
+                self.logger.info(f"🌪️ 搅拌加速过滤，预计时间减少20% ⚡")
             if temp > 50.0:
                 base_time *= 0.7  # 高温加速过滤
+                self.logger.info(f"🔥 高温加速过滤，预计时间减少30% ⚡")
+            
             filter_time = max(base_time, 10.0)  # 最少10秒
+            self.logger.info(f"⏱️ 预计过滤时间: {filter_time:.1f}秒 ⌛")
             
             while True:
                 current_time = time_module.time()
@@ -133,20 +155,24 @@ class VirtualFilter:
                 current_filtered = (progress / 100.0) * filter_volume
                 
                 # 更新状态 - 按照 Filter.action feedback 字段
-                status_msg = f"过滤中: {vessel}"
+                status_msg = f"🌊 过滤中: {vessel}"
                 if stir:
-                    status_msg += f" | 搅拌: {stir_speed} RPM"
-                status_msg += f" | {temp}°C | {progress:.1f}% | 已过滤: {current_filtered:.1f}mL"
+                    status_msg += f" | 🌪️ 搅拌: {stir_speed} RPM"
+                status_msg += f" | 🌡️ {temp}°C | 📊 {progress:.1f}% | 💧 已过滤: {current_filtered:.1f}mL"
                 
                 self.data.update({
                     "progress": progress,               # Filter.action feedback
                     "current_temp": temp,              # Filter.action feedback
                     "filtered_volume": current_filtered, # Filter.action feedback
-                    "current_status": f"Filtering: {progress:.1f}% complete", # Filter.action feedback
+                    "current_status": f"🌊 Filtering: {progress:.1f}% complete", # Filter.action feedback
                     "status": status_msg,
-                    "message": f"Filtering: {progress:.1f}% complete, {current_filtered:.1f}mL filtered"
+                    "message": f"🌊 Filtering: {progress:.1f}% complete, {current_filtered:.1f}mL filtered"
                 })
                 
+                # 进度日志（每25%打印一次）
+                if progress >= 25 and progress % 25 < 1:
+                    self.logger.info(f"📊 过滤进度: {progress:.0f}% | 💧 {current_filtered:.1f}mL 完成 ✨")
+                
                 if remaining <= 0:
                     break
                 
@@ -154,54 +180,57 @@ class VirtualFilter:
             
             # 过滤完成
             final_temp = temp if continue_heatchill else 25.0
-            final_status = f"过滤完成: {vessel} | {filter_volume}mL → {filtrate_vessel}"
+            final_status = f"✅ 过滤完成: {vessel} | 💧 {filter_volume}mL → {filtrate_vessel}"
             if continue_heatchill:
-                final_status += " | 继续加热搅拌"
+                final_status += " | 🔥 继续加热搅拌"
+                self.logger.info(f"🔥 继续保持加热搅拌状态 🌪️")
             
             self.data.update({
                 "status": final_status,
                 "progress": 100.0,                    # Filter.action feedback
                 "current_temp": final_temp,           # Filter.action feedback
                 "filtered_volume": filter_volume,     # Filter.action feedback
-                "current_status": f"Filtration completed: {filter_volume}mL", # Filter.action feedback
-                "message": f"Filtration completed: {filter_volume}mL filtered from {vessel}"
+                "current_status": f"✅ Filtration completed: {filter_volume}mL", # Filter.action feedback
+                "message": f"✅ Filtration completed: {filter_volume}mL filtered from {vessel}"
             })
             
-            self.logger.info(f"Filtration completed: {filter_volume}mL from {vessel} to {filtrate_vessel}")
+            self.logger.info(f"🎉 过滤完成! 💧 {filter_volume}mL 从 {vessel} 过滤到 {filtrate_vessel} ✨")
+            self.logger.info(f"📊 最终状态: 温度 {final_temp}°C | 进度 100% | 体积 {filter_volume}mL 🏁")
             return True
             
         except Exception as e:
-            self.logger.error(f"Error during filtration: {str(e)}")
+            error_msg = f"过滤过程中发生错误: {str(e)} 💥"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"过滤错误: {str(e)}",
-                "current_status": f"Filtration failed: {str(e)}",
-                "message": f"Filtration failed: {str(e)}"
+                "status": f"❌ 过滤错误: {str(e)}",
+                "current_status": f"❌ Filtration failed: {str(e)}",
+                "message": f"❌ Filtration failed: {str(e)}"
             })
             return False
     
     # === 核心状态属性 - 按照 Filter.action feedback 字段 ===
     @property
     def status(self) -> str:
-        return self.data.get("status", "Unknown")
+        return self.data.get("status", "❓ Unknown")
     
     @property
     def progress(self) -> float:
-        """Filter.action feedback 字段"""
+        """Filter.action feedback 字段 📊"""
         return self.data.get("progress", 0.0)
     
     @property
     def current_temp(self) -> float:
-        """Filter.action feedback 字段"""
+        """Filter.action feedback 字段 🌡️"""
         return self.data.get("current_temp", 25.0)
     
     @property
     def filtered_volume(self) -> float:
-        """Filter.action feedback 字段"""
+        """Filter.action feedback 字段 💧"""
         return self.data.get("filtered_volume", 0.0)
     
     @property
     def current_status(self) -> str:
-        """Filter.action feedback 字段"""
+        """Filter.action feedback 字段 📋"""
         return self.data.get("current_status", "")
     
     @property

unilabos/devices/virtual/virtual_heatchill.py

@@ -4,7 +4,7 @@ import time as time_module  # 重命名time模块，避免与参数冲突
 from typing import Dict, Any
 
 class VirtualHeatChill:
-    """Virtual heat chill device for HeatChillProtocol testing"""
+    """Virtual heat chill device for HeatChillProtocol testing 🌡️"""
     
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -31,94 +31,149 @@ class VirtualHeatChill:
         for key, value in kwargs.items():
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
+        
+        print(f"🌡️ === 虚拟温控设备 {self.device_id} 已创建 === ✨")
+        print(f"🔥 温度范围: {self._min_temp}°C ~ {self._max_temp}°C | 🌪️ 最大搅拌: {self._max_stir_speed} RPM")
     
     async def initialize(self) -> bool:
-        """Initialize virtual heat chill"""
-        self.logger.info(f"Initializing virtual heat chill {self.device_id}")
+        """Initialize virtual heat chill 🚀"""
+        self.logger.info(f"🔧 初始化虚拟温控设备 {self.device_id} ✨")
         
         # 初始化状态信息
         self.data.update({
-            "status": "Idle",
+            "status": "🏠 待机中",
             "operation_mode": "Idle",
             "is_stirring": False,
             "stir_speed": 0.0,
             "remaining_time": 0.0,
         })
+        
+        self.logger.info(f"✅ 温控设备 {self.device_id} 初始化完成 🌡️")
+        self.logger.info(f"📊 设备规格: 温度范围 {self._min_temp}°C ~ {self._max_temp}°C | 搅拌范围 0 ~ {self._max_stir_speed} RPM")
         return True
     
     async def cleanup(self) -> bool:
-        """Cleanup virtual heat chill"""
-        self.logger.info(f"Cleaning up virtual heat chill {self.device_id}")
+        """Cleanup virtual heat chill 🧹"""
+        self.logger.info(f"🧹 清理虚拟温控设备 {self.device_id} 🔚")
+        
         self.data.update({
-            "status": "Offline",
+            "status": "💤 离线",
             "operation_mode": "Offline",
             "is_stirring": False,
             "stir_speed": 0.0,
             "remaining_time": 0.0
         })
+        
+        self.logger.info(f"✅ 温控设备 {self.device_id} 清理完成 💤")
         return True
     
-    async def heat_chill(self, vessel: str, temp: float, time: float, stir: bool, 
+    async def heat_chill(self, vessel: str, temp: float, time, stir: bool, 
                         stir_speed: float, purpose: str) -> bool:
-        """Execute heat chill action - 按实际时间运行，实时更新剩余时间"""
-        self.logger.info(f"HeatChill: vessel={vessel}, temp={temp}°C, time={time}s, stir={stir}, stir_speed={stir_speed}")
+        """Execute heat chill action - 🔧 修复：确保参数类型正确"""
         
-        # 验证参数
-        if temp > self._max_temp or temp < self._min_temp:
-            error_msg = f"温度 {temp}°C 超出范围 ({self._min_temp}°C - {self._max_temp}°C)"
-            self.logger.error(error_msg)
+        # 🔧 关键修复：确保所有参数类型正确
+        try:
+            temp = float(temp)
+            time_value = float(time)  # 强制转换为浮点数
+            stir_speed = float(stir_speed)
+            stir = bool(stir)
+            vessel = str(vessel)
+            purpose = str(purpose)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换错误: temp={temp}({type(temp)}), time={time}({type(time)}), error={str(e)}"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: {error_msg}",
+                "operation_mode": "Error"
+            })
+            return False
+        
+        # 确定温度操作emoji
+        if temp > 25.0:
+            temp_emoji = "🔥"
+            operation_mode = "Heating"
+            status_action = "加热"
+        elif temp < 25.0:
+            temp_emoji = "❄️"
+            operation_mode = "Cooling"
+            status_action = "冷却"
+        else:
+            temp_emoji = "🌡️"
+            operation_mode = "Maintaining"
+            status_action = "保温"
+        
+        self.logger.info(f"🌡️ 开始温控操作: {vessel} → {temp}°C {temp_emoji}")
+        self.logger.info(f"  🥽 容器: {vessel}")
+        self.logger.info(f"  🎯 目标温度: {temp}°C {temp_emoji}")
+        self.logger.info(f"  ⏰ 持续时间: {time_value}s")
+        self.logger.info(f"  🌪️ 搅拌: {stir} ({stir_speed} RPM)")
+        self.logger.info(f"  📝 目的: {purpose}")
+        
+        # 验证参数范围
+        if temp > self._max_temp or temp < self._min_temp:
+            error_msg = f"🌡️ 温度 {temp}°C 超出范围 ({self._min_temp}°C - {self._max_temp}°C) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
+            self.data.update({
+                "status": f"❌ 错误: 温度超出范围 ⚠️",
                 "operation_mode": "Error"
             })
             return False
         
         if stir and stir_speed > self._max_stir_speed:
-            error_msg = f"搅拌速度 {stir_speed} RPM 超出最大值 {self._max_stir_speed} RPM"
-            self.logger.error(error_msg)
+            error_msg = f"🌪️ 搅拌速度 {stir_speed} RPM 超出最大值 {self._max_stir_speed} RPM ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: 搅拌速度超出范围 ⚠️",
                 "operation_mode": "Error"
             })
             return False
         
-        # 确定操作模式
-        if temp > 25.0:
-            operation_mode = "Heating"
-            status_action = "加热"
-        elif temp < 25.0:
-            operation_mode = "Cooling"
-            status_action = "冷却"
-        else:
-            operation_mode = "Maintaining"
-            status_action = "保温"
+        if time_value <= 0:
+            error_msg = f"⏰ 时间 {time_value}s 必须大于0 ⚠️"
+            self.logger.error(f"❌ {error_msg}")
+            self.data.update({
+                "status": f"❌ 错误: 时间参数无效 ⚠️",
+                "operation_mode": "Error"
+            })
+            return False
         
-        # **修复**: 使用重命名的time模块
+        # 🔧 修复：使用转换后的时间值
         start_time = time_module.time()
-        total_time = time
+        total_time = time_value  # 使用转换后的浮点数
+        
+        self.logger.info(f"🚀 开始{status_action}程序! 预计用时 {total_time:.1f}秒 ⏱️")
         
         # 开始操作
-        stir_info = f" | 搅拌: {stir_speed} RPM" if stir else ""
+        stir_info = f" | 🌪️ 搅拌: {stir_speed} RPM" if stir else ""
+        
         self.data.update({
-            "status": f"运行中: {status_action} {vessel} 至 {temp}°C | 剩余: {total_time:.0f}s{stir_info}",
+            "status": f"{temp_emoji} 运行中: {status_action} {vessel} 至 {temp}°C | ⏰ 剩余: {total_time:.0f}s{stir_info}",
             "operation_mode": operation_mode,
             "is_stirring": stir,
             "stir_speed": stir_speed if stir else 0.0,
             "remaining_time": total_time,
         })
         
-        # **修复**: 在等待过程中每秒更新剩余时间
+        # 在等待过程中每秒更新剩余时间
+        last_logged_time = 0
         while True:
-            current_time = time_module.time()  # 使用重命名的time模块
+            current_time = time_module.time()
             elapsed = current_time - start_time
             remaining = max(0, total_time - elapsed)
+            progress = (elapsed / total_time) * 100 if total_time > 0 else 100
             
             # 更新剩余时间和状态
             self.data.update({
                 "remaining_time": remaining,
-                "status": f"运行中: {status_action} {vessel} 至 {temp}°C | 剩余: {remaining:.0f}s{stir_info}"
+                "status": f"{temp_emoji} 运行中: {status_action} {vessel} 至 {temp}°C | ⏰ 剩余: {remaining:.0f}s{stir_info}",
+                "progress": progress
             })
             
+            # 进度日志（每25%打印一次）
+            if progress >= 25 and int(progress) % 25 == 0 and int(progress) != last_logged_time:
+                self.logger.info(f"📊 {status_action}进度: {progress:.0f}% | ⏰ 剩余: {remaining:.0f}s | {temp_emoji} 目标: {temp}°C ✨")
+                last_logged_time = int(progress)
+            
             # 如果时间到了，退出循环
             if remaining <= 0:
                 break
@@ -127,71 +182,114 @@ class VirtualHeatChill:
             await asyncio.sleep(1.0)
         
         # 操作完成
-        final_stir_info = f" | 搅拌: {stir_speed} RPM" if stir else ""
+        final_stir_info = f" | 🌪️ 搅拌: {stir_speed} RPM" if stir else ""
+        
         self.data.update({
-            "status": f"完成: {vessel} 已达到 {temp}°C | 用时: {total_time:.0f}s{final_stir_info}",
+            "status": f"✅ 完成: {vessel} 已达到 {temp}°C {temp_emoji} | ⏱️ 用时: {total_time:.0f}s{final_stir_info}",
             "operation_mode": "Completed",
             "remaining_time": 0.0,
             "is_stirring": False,
-            "stir_speed": 0.0
+            "stir_speed": 0.0,
+            "progress": 100.0
         })
         
-        self.logger.info(f"HeatChill completed for vessel {vessel} at {temp}°C after {total_time}s")
+        self.logger.info(f"🎉 温控操作完成! ✨")
+        self.logger.info(f"📊 操作结果:")
+        self.logger.info(f"  🥽 容器: {vessel}")
+        self.logger.info(f"  🌡️ 达到温度: {temp}°C {temp_emoji}")
+        self.logger.info(f"  ⏱️ 总用时: {total_time:.0f}s")
+        if stir:
+            self.logger.info(f"  🌪️ 搅拌速度: {stir_speed} RPM")
+        self.logger.info(f"  📝 操作目的: {purpose} 🏁")
+        
         return True
     
     async def heat_chill_start(self, vessel: str, temp: float, purpose: str) -> bool:
-        """Start continuous heat chill"""
-        self.logger.info(f"HeatChillStart: vessel={vessel}, temp={temp}°C")
+        """Start continuous heat chill 🔄"""
         
-        # 验证参数
-        if temp > self._max_temp or temp < self._min_temp:
-            error_msg = f"温度 {temp}°C 超出范围 ({self._min_temp}°C - {self._max_temp}°C)"
-            self.logger.error(error_msg)
+        # 🔧 添加类型转换
+        try:
+            temp = float(temp)
+            vessel = str(vessel)
+            purpose = str(purpose)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换错误: {str(e)}"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: {error_msg}",
                 "operation_mode": "Error"
             })
             return False
         
-        # 确定操作模式
+        # 确定温度操作emoji
         if temp > 25.0:
+            temp_emoji = "🔥"
             operation_mode = "Heating"
             status_action = "持续加热"
         elif temp < 25.0:
+            temp_emoji = "❄️"
             operation_mode = "Cooling"
             status_action = "持续冷却"
         else:
+            temp_emoji = "🌡️"
             operation_mode = "Maintaining"
             status_action = "恒温保持"
         
+        self.logger.info(f"🔄 启动持续温控: {vessel} → {temp}°C {temp_emoji}")
+        self.logger.info(f"  🥽 容器: {vessel}")
+        self.logger.info(f"  🎯 目标温度: {temp}°C {temp_emoji}")
+        self.logger.info(f"  🔄 模式: {status_action}")
+        self.logger.info(f"  📝 目的: {purpose}")
+        
+        # 验证参数
+        if temp > self._max_temp or temp < self._min_temp:
+            error_msg = f"🌡️ 温度 {temp}°C 超出范围 ({self._min_temp}°C - {self._max_temp}°C) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
+            self.data.update({
+                "status": f"❌ 错误: 温度超出范围 ⚠️",
+                "operation_mode": "Error"
+            })
+            return False
+        
         self.data.update({
-            "status": f"启动: {status_action} {vessel} 至 {temp}°C | 持续运行",
+            "status": f"🔄 启动: {status_action} {vessel} 至 {temp}°C {temp_emoji} | ♾️ 持续运行",
             "operation_mode": operation_mode,
             "is_stirring": False,
             "stir_speed": 0.0,
             "remaining_time": -1.0,  # -1 表示持续运行
         })
         
+        self.logger.info(f"✅ 持续温控已启动! {temp_emoji} {status_action}模式 🚀")
         return True
     
     async def heat_chill_stop(self, vessel: str) -> bool:
-        """Stop heat chill"""
-        self.logger.info(f"HeatChillStop: vessel={vessel}")
+        """Stop heat chill 🛑"""
+        
+        # 🔧 添加类型转换
+        try:
+            vessel = str(vessel)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换错误: {str(e)}"
+            self.logger.error(f"❌ {error_msg}")
+            return False
+        
+        self.logger.info(f"🛑 停止温控: {vessel}")
         
         self.data.update({
-            "status": f"已停止: {vessel} 温控停止",
+            "status": f"🛑 已停止: {vessel} 温控停止",
             "operation_mode": "Stopped",
             "is_stirring": False,
             "stir_speed": 0.0,
             "remaining_time": 0.0,
         })
         
+        self.logger.info(f"✅ 温控设备已停止 {vessel} 的温度控制 🏁")
         return True
     
     # 状态属性
     @property
     def status(self) -> str:
-        return self.data.get("status", "Idle")
+        return self.data.get("status", "🏠 待机中")
     
     @property
     def operation_mode(self) -> str:
@@ -207,4 +305,20 @@ class VirtualHeatChill:
     
     @property
     def remaining_time(self) -> float:
-        return self.data.get("remaining_time", 0.0)
+        return self.data.get("remaining_time", 0.0)
+    
+    @property
+    def progress(self) -> float:
+        return self.data.get("progress", 0.0)
+    
+    @property
+    def max_temp(self) -> float:
+        return self._max_temp
+    
+    @property
+    def min_temp(self) -> float:
+        return self._min_temp
+    
+    @property
+    def max_stir_speed(self) -> float:
+        return self._max_stir_speed

unilabos/devices/virtual/virtual_multiway_valve.py

@@ -1,16 +1,20 @@
 import time
+import logging
 from typing import Union, Dict, Optional
 
 
 class VirtualMultiwayValve:
     """
-    虚拟九通阀门 - 0号位连接transfer pump，1-8号位连接其他设备
+    虚拟九通阀门 - 0号位连接transfer pump，1-8号位连接其他设备 🔄
     """
     def __init__(self, port: str = "VIRTUAL", positions: int = 8):
         self.port = port
         self.max_positions = positions  # 1-8号位
         self.total_positions = positions + 1  # 0-8号位，共9个位置
         
+        # 添加日志记录器
+        self.logger = logging.getLogger(f"VirtualMultiwayValve.{port}")
+        
         # 状态属性
         self._status = "Idle"
         self._valve_state = "Ready"
@@ -29,6 +33,10 @@ class VirtualMultiwayValve:
             7: "port_7",         # 7号位
             8: "port_8"          # 8号位
         }
+        
+        print(f"🔄 === 虚拟多通阀门已创建 === ✨")
+        print(f"🎯 端口: {port} | 📊 位置范围: 0-{self.max_positions} | 🏠 初始位置: 0 (transfer_pump)")
+        self.logger.info(f"🔧 多通阀门初始化: 端口={port}, 最大位置={self.max_positions}")
 
     @property
     def status(self) -> str:
@@ -47,16 +55,16 @@ class VirtualMultiwayValve:
         return self._target_position
 
     def get_current_position(self) -> int:
-        """获取当前阀门位置"""
+        """获取当前阀门位置 📍"""
         return self._current_position
 
     def get_current_port(self) -> str:
-        """获取当前连接的端口名称"""
+        """获取当前连接的端口名称 🔌"""
         return self.position_map.get(self._current_position, "unknown")
 
     def set_position(self, command: Union[int, str]):
         """
-        设置阀门位置 - 支持0-8位置
+        设置阀门位置 - 支持0-8位置 🎯
         
         Args:
             command: 目标位置 (0-8) 或位置字符串
@@ -71,7 +79,22 @@ class VirtualMultiwayValve:
                 pos = int(command)
                 
             if pos < 0 or pos > self.max_positions:
-                raise ValueError(f"Position must be between 0 and {self.max_positions}")
+                error_msg = f"位置必须在 0-{self.max_positions} 范围内"
+                self.logger.error(f"❌ {error_msg}: 请求位置={pos}")
+                raise ValueError(error_msg)
+            
+            # 获取位置描述emoji
+            if pos == 0:
+                pos_emoji = "🚰"
+                pos_desc = "泵位置"
+            else:
+                pos_emoji = "🔌"
+                pos_desc = f"端口{pos}"
+            
+            old_position = self._current_position
+            old_port = self.get_current_port()
+            
+            self.logger.info(f"🔄 阀门切换: {old_position}({old_port}) → {pos}({self.position_map.get(pos, 'unknown')}) {pos_emoji}")
             
             self._status = "Busy"
             self._valve_state = "Moving"
@@ -79,104 +102,139 @@ class VirtualMultiwayValve:
             
             # 模拟阀门切换时间
             switch_time = abs(self._current_position - pos) * 0.5  # 每个位置0.5秒
-            time.sleep(switch_time)
+
+            if switch_time > 0:
+                self.logger.info(f"⏱️ 阀门移动中... 预计用时: {switch_time:.1f}秒 🔄")
+                time.sleep(switch_time)
             
             self._current_position = pos
             self._status = "Idle"
             self._valve_state = "Ready"
             
             current_port = self.get_current_port()
-            return f"Position set to {pos} ({current_port})"
+            success_msg = f"✅ 阀门已切换到位置 {pos} ({current_port}) {pos_emoji}"
+            
+            self.logger.info(success_msg)
+            return success_msg
             
         except ValueError as e:
+            error_msg = f"❌ 阀门切换失败: {str(e)}"
             self._status = "Error"
             self._valve_state = "Error"
-            return f"Error: {str(e)}"
+            self.logger.error(error_msg)
+            return error_msg
 
     def set_to_pump_position(self):
-        """切换到transfer pump位置（0号位）"""
+        """切换到transfer pump位置（0号位）🚰"""
+        self.logger.info(f"🚰 切换到泵位置...")
         return self.set_position(0)
 
     def set_to_port(self, port_number: int):
         """
-        切换到指定端口位置
+        切换到指定端口位置 🔌
         
         Args:
             port_number: 端口号 (1-8)
         """
         if port_number < 1 or port_number > self.max_positions:
-            raise ValueError(f"Port number must be between 1 and {self.max_positions}")
+            error_msg = f"端口号必须在 1-{self.max_positions} 范围内"
+            self.logger.error(f"❌ {error_msg}: 请求端口={port_number}")
+            raise ValueError(error_msg)
+        
+        self.logger.info(f"🔌 切换到端口 {port_number}...")
         return self.set_position(port_number)
 
     def open(self):
-        """打开阀门 - 设置到transfer pump位置（0号位）"""
+        """打开阀门 - 设置到transfer pump位置（0号位）🔓"""
+        self.logger.info(f"🔓 打开阀门，设置到泵位置...")
         return self.set_to_pump_position()
 
     def close(self):
-        """关闭阀门 - 对于多通阀门，设置到一个"关闭"状态"""
+        """关闭阀门 - 对于多通阀门，设置到一个"关闭"状态 🔒"""
+        self.logger.info(f"🔒 关闭阀门...")
+        
         self._status = "Busy"
         self._valve_state = "Closing"
         time.sleep(0.5)
-        
+
         # 可以选择保持当前位置或设置特殊关闭状态
         self._status = "Idle"
         self._valve_state = "Closed"
         
-        return f"Valve closed at position {self._current_position}"
+        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.get_current_port()})"
+        self.logger.info(close_msg)
+        return close_msg
 
     def get_valve_position(self) -> int:
-        """获取阀门位置 - 兼容性方法"""
+        """获取阀门位置 - 兼容性方法 📍"""
         return self._current_position
 
     def is_at_position(self, position: int) -> bool:
-        """检查是否在指定位置"""
-        return self._current_position == position
+        """检查是否在指定位置 🎯"""
+        result = self._current_position == position
+        # 删除debug日志：self.logger.debug(f"🎯 位置检查: 当前={self._current_position}, 目标={position}, 匹配={result}")
+        return result
 
     def is_at_pump_position(self) -> bool:
-        """检查是否在transfer pump位置"""
-        return self._current_position == 0
+        """检查是否在transfer pump位置 🚰"""
+        result = self._current_position == 0
+        # 删除debug日志：pump_status = "是" if result else "否"
+        # 删除debug日志：self.logger.debug(f"🚰 泵位置检查: {pump_status} (当前位置: {self._current_position})")
+        return result
 
     def is_at_port(self, port_number: int) -> bool:
-        """检查是否在指定端口位置"""
-        return self._current_position == port_number
+        """检查是否在指定端口位置 🔌"""
+        result = self._current_position == port_number
+        # 删除debug日志：port_status = "是" if result else "否"
+        # 删除debug日志：self.logger.debug(f"🔌 端口{port_number}检查: {port_status} (当前位置: {self._current_position})")
+        return result
 
     def get_available_positions(self) -> list:
-        """获取可用位置列表"""
-        return list(range(0, self.max_positions + 1))
+        """获取可用位置列表 📋"""
+        positions = list(range(0, self.max_positions + 1))
+        # 删除debug日志：self.logger.debug(f"📋 可用位置: {positions}")
+        return positions
 
     def get_available_ports(self) -> Dict[int, str]:
-        """获取可用端口映射"""
+        """获取可用端口映射 🗺️"""
+        # 删除debug日志：self.logger.debug(f"🗺️ 端口映射: {self.position_map}")
         return self.position_map.copy()
 
     def reset(self):
-        """重置阀门到transfer pump位置（0号位）"""
+        """重置阀门到transfer pump位置（0号位）🔄"""
+        self.logger.info(f"🔄 重置阀门到泵位置...")
         return self.set_position(0)
 
     def switch_between_pump_and_port(self, port_number: int):
         """
-        在transfer pump位置和指定端口之间切换
+        在transfer pump位置和指定端口之间切换 🔄
         
         Args:
             port_number: 目标端口号 (1-8)
         """
         if self._current_position == 0:
             # 当前在pump位置，切换到指定端口
+            self.logger.info(f"🔄 从泵位置切换到端口 {port_number}...")
             return self.set_to_port(port_number)
         else:
             # 当前在某个端口，切换到pump位置
+            self.logger.info(f"🔄 从端口 {self._current_position} 切换到泵位置...")
             return self.set_to_pump_position()
 
     def get_flow_path(self) -> str:
-        """获取当前流路路径描述"""
+        """获取当前流路路径描述 🌊"""
         current_port = self.get_current_port()
         if self._current_position == 0:
-            return f"Transfer pump connected (position {self._current_position})"
+            flow_path = f"🚰 转移泵已连接 (位置 {self._current_position})"
         else:
-            return f"Port {self._current_position} connected ({current_port})"
+            flow_path = f"🔌 端口 {self._current_position} 已连接 ({current_port})"
+        
+        # 删除debug日志：self.logger.debug(f"🌊 当前流路: {flow_path}")
+        return flow_path
 
     def get_info(self) -> dict:
-        """获取阀门详细信息"""
-        return {
+        """获取阀门详细信息 📊"""
+        info = {
             "port": self.port,
             "max_positions": self.max_positions,
             "total_positions": self.total_positions,
@@ -188,18 +246,25 @@ class VirtualMultiwayValve:
             "flow_path": self.get_flow_path(),
             "position_map": self.position_map
         }
+        
+        # 删除debug日志：self.logger.debug(f"📊 阀门信息: 位置={self._current_position}, 状态={self._status}, 端口={self.get_current_port()}")
+        return info
 
     def __str__(self):
-        return f"VirtualMultiwayValve(Position: {self._current_position}/{self.max_positions}, Port: {self.get_current_port()}, Status: {self._status})"
+        current_port = self.get_current_port()
+        status_emoji = "✅" if self._status == "Idle" else "🔄" if self._status == "Busy" else "❌"
+        
+        return f"🔄 VirtualMultiwayValve({status_emoji} 位置: {self._current_position}/{self.max_positions}, 端口: {current_port}, 状态: {self._status})"
 
     def set_valve_position(self, command: Union[int, str]):
         """
-        设置阀门位置 - 兼容pump_protocol调用
+        设置阀门位置 - 兼容pump_protocol调用 🎯
         这是set_position的别名方法，用于兼容pump_protocol.py
         
         Args:
             command: 目标位置 (0-8) 或位置字符串
         """
+        # 删除debug日志：self.logger.debug(f"🎯 兼容性调用: set_valve_position({command})")
         return self.set_position(command)
 
 
@@ -207,25 +272,35 @@ class VirtualMultiwayValve:
 if __name__ == "__main__":
     valve = VirtualMultiwayValve()
     
-    print("=== 虚拟九通阀门测试 ===")
-    print(f"初始状态: {valve}")
-    print(f"当前流路: {valve.get_flow_path()}")
+    print("🔄 === 虚拟九通阀门测试 === ✨")
+    print(f"🏠 初始状态: {valve}")
+    print(f"🌊 当前流路: {valve.get_flow_path()}")
     
     # 切换到试剂瓶1（1号位）
-    print(f"\n切换到1号位: {valve.set_position(1)}")
-    print(f"当前状态: {valve}")
+    print(f"\n🔌 切换到1号位: {valve.set_position(1)}")
+    print(f"📍 当前状态: {valve}")
     
     # 切换到transfer pump位置（0号位）
-    print(f"\n切换到pump位置: {valve.set_to_pump_position()}")
-    print(f"当前状态: {valve}")
+    print(f"\n🚰 切换到pump位置: {valve.set_to_pump_position()}")
+    print(f"📍 当前状态: {valve}")
     
     # 切换到试剂瓶2（2号位）
-    print(f"\n切换到2号位: {valve.set_to_port(2)}")
-    print(f"当前状态: {valve}")
+    print(f"\n🔌 切换到2号位: {valve.set_to_port(2)}")
+    print(f"📍 当前状态: {valve}")
     
     # 显示所有可用位置
-    print(f"\n可用位置: {valve.get_available_positions()}")
-    print(f"端口映射: {valve.get_available_ports()}")
+    print(f"\n📋 可用位置: {valve.get_available_positions()}")
+    print(f"🗺️ 端口映射: {valve.get_available_ports()}")
     
     # 获取详细信息
-    print(f"\n详细信息: {valve.get_info()}")
+    print(f"\n📊 详细信息: {valve.get_info()}")
+    
+    # 测试切换功能
+    print(f"\n🔄 智能切换测试:")
+    print(f"当前位置: {valve._current_position}")
+    print(f"切换结果: {valve.switch_between_pump_and_port(3)}")
+    print(f"新位置: {valve._current_position}")
+    
+    # 重置测试
+    print(f"\n🔄 重置测试: {valve.reset()}")
+    print(f"📍 重置后状态: {valve}")

unilabos/devices/virtual/virtual_rotavap.py

@@ -3,9 +3,12 @@ import logging
 import time as time_module
 from typing import Dict, Any, Optional
 
+def debug_print(message):
+    """调试输出 🔍"""
+    print(f"🌪️ [ROTAVAP] {message}", flush=True)
 
 class VirtualRotavap:
-    """Virtual rotary evaporator device - 简化版，只保留核心功能"""
+    """Virtual rotary evaporator device - 简化版，只保留核心功能 🌪️"""
 
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -32,13 +35,16 @@ class VirtualRotavap:
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
 
+        print(f"🌪️ === 虚拟旋转蒸发仪 {self.device_id} 已创建 === ✨")
+        print(f"🔥 温度范围: 10°C ~ {self._max_temp}°C | 🌀 转速范围: 10 ~ {self._max_rotation_speed} RPM")
+
     async def initialize(self) -> bool:
-        """Initialize virtual rotary evaporator"""
-        self.logger.info(f"Initializing virtual rotary evaporator {self.device_id}")
+        """Initialize virtual rotary evaporator 🚀"""
+        self.logger.info(f"🔧 初始化虚拟旋转蒸发仪 {self.device_id} ✨")
         
         # 只保留核心状态
         self.data.update({
-            "status": "Idle",
+            "status": "🏠 待机中",
             "rotavap_state": "Ready",  # Ready, Evaporating, Completed, Error
             "current_temp": 25.0,
             "target_temp": 25.0,
@@ -47,22 +53,27 @@ class VirtualRotavap:
             "evaporated_volume": 0.0,
             "progress": 0.0,
             "remaining_time": 0.0,
-            "message": "Ready for evaporation"
+            "message": "🌪️ Ready for evaporation"
         })
+        
+        self.logger.info(f"✅ 旋转蒸发仪 {self.device_id} 初始化完成 🌪️")
+        self.logger.info(f"📊 设备规格: 温度范围 10°C ~ {self._max_temp}°C | 转速范围 10 ~ {self._max_rotation_speed} RPM")
         return True
 
     async def cleanup(self) -> bool:
-        """Cleanup virtual rotary evaporator"""
-        self.logger.info(f"Cleaning up virtual rotary evaporator {self.device_id}")
+        """Cleanup virtual rotary evaporator 🧹"""
+        self.logger.info(f"🧹 清理虚拟旋转蒸发仪 {self.device_id} 🔚")
         
         self.data.update({
-            "status": "Offline",
+            "status": "💤 离线",
             "rotavap_state": "Offline",
             "current_temp": 25.0,
             "rotation_speed": 0.0,
             "vacuum_pressure": 1.0,
-            "message": "System offline"
+            "message": "💤 System offline"
         })
+        
+        self.logger.info(f"✅ 旋转蒸发仪 {self.device_id} 清理完成 💤")
         return True
 
     async def evaporate(
@@ -70,46 +81,88 @@ class VirtualRotavap:
         vessel: str, 
         pressure: float = 0.1, 
         temp: float = 60.0, 
-        time: float = 1800.0,  # 30分钟默认
-        stir_speed: float = 100.0
+        time: float = 180.0,
+        stir_speed: float = 100.0,
+        solvent: str = "",
+        **kwargs
     ) -> bool:
-        """Execute evaporate action - 简化的蒸发流程"""
-        self.logger.info(f"Evaporate: vessel={vessel}, pressure={pressure} bar, temp={temp}°C, time={time}s, rotation={stir_speed} RPM")
-
+        """Execute evaporate action - 简化版 🌪️"""
+        
+        # 🔧 简化处理：如果vessel就是设备自己，直接操作
+        if vessel == self.device_id:
+            debug_print(f"🎯 在设备 {self.device_id} 上直接执行蒸发操作")
+            actual_vessel = self.device_id
+        else:
+            actual_vessel = vessel
+        
+        # 参数预处理
+        if solvent:
+            self.logger.info(f"🧪 识别到溶剂: {solvent}")
+            # 根据溶剂调整参数
+            solvent_lower = solvent.lower()
+            if any(s in solvent_lower for s in ['water', 'aqueous']):
+                temp = max(temp, 80.0)
+                pressure = max(pressure, 0.2)
+                self.logger.info(f"💧 水系溶剂：调整参数 → 温度 {temp}°C, 压力 {pressure} bar")
+            elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+                temp = min(temp, 50.0)
+                pressure = min(pressure, 0.05)
+                self.logger.info(f"⚡ 易挥发溶剂：调整参数 → 温度 {temp}°C, 压力 {pressure} bar")
+        
+        self.logger.info(f"🌪️ 开始蒸发操作: {actual_vessel}")
+        self.logger.info(f"  🥽 容器: {actual_vessel}")
+        self.logger.info(f"  🌡️ 温度: {temp}°C")
+        self.logger.info(f"  💨 真空度: {pressure} bar")
+        self.logger.info(f"  ⏰ 时间: {time}s")
+        self.logger.info(f"  🌀 转速: {stir_speed} RPM")
+        if solvent:
+            self.logger.info(f"  🧪 溶剂: {solvent}")
+        
         # 验证参数
         if temp > self._max_temp or temp < 10.0:
-            error_msg = f"温度 {temp}°C 超出范围 (10-{self._max_temp}°C)"
-            self.logger.error(error_msg)
+            error_msg = f"🌡️ 温度 {temp}°C 超出范围 (10-{self._max_temp}°C) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: 温度超出范围",
                 "rotavap_state": "Error",
+                "current_temp": 25.0,
+                "progress": 0.0,
+                "evaporated_volume": 0.0,
                 "message": error_msg
             })
             return False
 
         if stir_speed > self._max_rotation_speed or stir_speed < 10.0:
-            error_msg = f"旋转速度 {stir_speed} RPM 超出范围 (10-{self._max_rotation_speed} RPM)"
-            self.logger.error(error_msg)
+            error_msg = f"🌀 旋转速度 {stir_speed} RPM 超出范围 (10-{self._max_rotation_speed} RPM) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: 转速超出范围",
                 "rotavap_state": "Error",
+                "current_temp": 25.0,
+                "progress": 0.0,
+                "evaporated_volume": 0.0,
                 "message": error_msg
             })
             return False
 
         if pressure < 0.01 or pressure > 1.0:
-            error_msg = f"真空度 {pressure} bar 超出范围 (0.01-1.0 bar)"
-            self.logger.error(error_msg)
+            error_msg = f"💨 真空度 {pressure} bar 超出范围 (0.01-1.0 bar) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: 压力超出范围",
                 "rotavap_state": "Error",
+                "current_temp": 25.0,
+                "progress": 0.0,
+                "evaporated_volume": 0.0,
                 "message": error_msg
             })
             return False
 
         # 开始蒸发
+        self.logger.info(f"🚀 启动蒸发程序! 预计用时 {time/60:.1f}分钟 ⏱️")
+        
         self.data.update({
-            "status": f"蒸发中: {vessel}",
+            "status": f"🌪️ 蒸发中: {actual_vessel}",
             "rotavap_state": "Evaporating",
             "current_temp": temp,
             "target_temp": temp,
@@ -118,13 +171,14 @@ class VirtualRotavap:
             "remaining_time": time,
             "progress": 0.0,
             "evaporated_volume": 0.0,
-            "message": f"Evaporating {vessel} at {temp}°C, {pressure} bar, {stir_speed} RPM"
+            "message": f"🌪️ Evaporating {actual_vessel} at {temp}°C, {pressure} bar, {stir_speed} RPM"
         })
 
         try:
             # 蒸发过程 - 实时更新进度
             start_time = time_module.time()
             total_time = time
+            last_logged_progress = 0
             
             while True:
                 current_time = time_module.time()
@@ -132,18 +186,31 @@ class VirtualRotavap:
                 remaining = max(0, total_time - elapsed)
                 progress = min(100.0, (elapsed / total_time) * 100)
                 
-                # 模拟蒸发体积
-                evaporated_vol = progress * 0.8  # 假设最多蒸发80mL
+                # 模拟蒸发体积 - 根据溶剂类型调整
+                if solvent and any(s in solvent.lower() for s in ['water', 'aqueous']):
+                    evaporated_vol = progress * 0.6  # 水系溶剂蒸发慢
+                elif solvent and any(s in solvent.lower() for s in ['ethanol', 'methanol', 'acetone']):
+                    evaporated_vol = progress * 1.0  # 易挥发溶剂蒸发快
+                else:
+                    evaporated_vol = progress * 0.8  # 默认蒸发量
+                
+                # 🔧 更新状态 - 确保包含所有必需字段
+                status_msg = f"🌪️ 蒸发中: {actual_vessel} | 🌡️ {temp}°C | 💨 {pressure} bar | 🌀 {stir_speed} RPM | 📊 {progress:.1f}% | ⏰ 剩余: {remaining:.0f}s"
                 
-                # 更新状态
                 self.data.update({
                     "remaining_time": remaining,
                     "progress": progress,
                     "evaporated_volume": evaporated_vol,
-                    "status": f"蒸发中: {vessel} | {temp}°C | {pressure} bar | {progress:.1f}% | 剩余: {remaining:.0f}s",
-                    "message": f"Evaporating: {progress:.1f}% complete, {remaining:.0f}s remaining"
+                    "current_temp": temp,
+                    "status": status_msg,
+                    "message": f"🌪️ Evaporating: {progress:.1f}% complete, 💧 {evaporated_vol:.1f}mL evaporated, ⏰ {remaining:.0f}s remaining"
                 })
                 
+                # 进度日志（每25%打印一次）
+                if progress >= 25 and int(progress) % 25 == 0 and int(progress) != last_logged_progress:
+                    self.logger.info(f"📊 蒸发进度: {progress:.0f}% | 💧 已蒸发: {evaporated_vol:.1f}mL | ⏰ 剩余: {remaining:.0f}s ✨")
+                    last_logged_progress = int(progress)
+                
                 # 时间到了，退出循环
                 if remaining <= 0:
                     break
@@ -152,40 +219,59 @@ class VirtualRotavap:
                 await asyncio.sleep(1.0)
             
             # 蒸发完成
-            final_evaporated = 80.0
+            if solvent and any(s in solvent.lower() for s in ['water', 'aqueous']):
+                final_evaporated = 60.0  # 水系溶剂
+            elif solvent and any(s in solvent.lower() for s in ['ethanol', 'methanol', 'acetone']):
+                final_evaporated = 100.0  # 易挥发溶剂
+            else:
+                final_evaporated = 80.0  # 默认
+            
             self.data.update({
-                "status": f"蒸发完成: {vessel} | 蒸发量: {final_evaporated:.1f}mL",
+                "status": f"✅ 蒸发完成: {actual_vessel} | 💧 蒸发量: {final_evaporated:.1f}mL",
                 "rotavap_state": "Completed",
                 "evaporated_volume": final_evaporated,
                 "progress": 100.0,
+                "current_temp": temp,
                 "remaining_time": 0.0,
-                "current_temp": 25.0,  # 冷却下来
-                "rotation_speed": 0.0,  # 停止旋转
-                "vacuum_pressure": 1.0,  # 恢复大气压
-                "message": f"Evaporation completed: {final_evaporated}mL evaporated from {vessel}"
+                "rotation_speed": 0.0,
+                "vacuum_pressure": 1.0,
+                "message": f"✅ Evaporation completed: {final_evaporated}mL evaporated from {actual_vessel}"
             })
 
-            self.logger.info(f"Evaporation completed: {final_evaporated}mL evaporated from {vessel}")
+            self.logger.info(f"🎉 蒸发操作完成! ✨")
+            self.logger.info(f"📊 蒸发结果:")
+            self.logger.info(f"  🥽 容器: {actual_vessel}")
+            self.logger.info(f"  💧 蒸发量: {final_evaporated:.1f}mL")
+            self.logger.info(f"  🌡️ 蒸发温度: {temp}°C")
+            self.logger.info(f"  💨 真空度: {pressure} bar")
+            self.logger.info(f"  🌀 旋转速度: {stir_speed} RPM")
+            self.logger.info(f"  ⏱️ 总用时: {total_time:.0f}s")
+            if solvent:
+                self.logger.info(f"  🧪 处理溶剂: {solvent} 🏁")
+            
             return True
 
         except Exception as e:
             # 出错处理
-            self.logger.error(f"Error during evaporation: {str(e)}")
+            error_msg = f"蒸发过程中发生错误: {str(e)} 💥"
+            self.logger.error(f"❌ {error_msg}")
             
             self.data.update({
-                "status": f"蒸发错误: {str(e)}",
+                "status": f"❌ 蒸发错误: {str(e)}",
                 "rotavap_state": "Error",
                 "current_temp": 25.0,
+                "progress": 0.0,
+                "evaporated_volume": 0.0,
                 "rotation_speed": 0.0,
                 "vacuum_pressure": 1.0,
-                "message": f"Evaporation failed: {str(e)}"
+                "message": f"❌ Evaporation failed: {str(e)}"
             })
             return False
 
     # === 核心状态属性 ===
     @property
     def status(self) -> str:
-        return self.data.get("status", "Unknown")
+        return self.data.get("status", "❓ Unknown")
 
     @property
     def rotavap_state(self) -> str:

unilabos/devices/virtual/virtual_solenoid_valve.py

@@ -43,10 +43,25 @@ class VirtualSolenoidValve:
     def is_open(self) -> bool:
         return self._is_open
 
-    def get_valve_position(self) -> str:
+    @property
+    def valve_position(self) -> str:
         """获取阀门位置状态"""
         return "OPEN" if self._is_open else "CLOSED"
 
+    @property
+    def state(self) -> dict:
+        """获取阀门完整状态"""
+        return {
+            "device_id": self.device_id,
+            "port": self.port,
+            "voltage": self.voltage,
+            "response_time": self.response_time,
+            "is_open": self._is_open,
+            "valve_state": self._valve_state,
+            "status": self._status,
+            "position": self.valve_position
+        }
+
     async def set_valve_position(self, command: str = None, **kwargs):
         """
         设置阀门位置 - ROS动作接口
@@ -91,7 +106,7 @@ class VirtualSolenoidValve:
         return {
             "success": True, 
             "message": result_msg,
-            "valve_position": self.get_valve_position()
+            "valve_position": self.valve_position
         }
 
     async def open(self, **kwargs):
@@ -102,21 +117,25 @@ class VirtualSolenoidValve:
         """关闭电磁阀 - ROS动作接口"""
         return await self.set_valve_position(command="CLOSED")
 
-    async def set_state(self, command: Union[bool, str], **kwargs):
+    async def set_status(self, string: str = None, **kwargs):
         """
-        设置阀门状态 - 兼容 SendCmd 类型
+        设置阀门状态 - 兼容 StrSingleInput 类型
     
         Args:
-            command: True/False 或 "open"/"close"
+            string: "ON"/"OFF" 或 "OPEN"/"CLOSED"
         """
-        if isinstance(command, bool):
-            cmd_str = "OPEN" if command else "CLOSED"
-        elif isinstance(command, str):
-            cmd_str = command
-        else:
-            return {"success": False, "message": "Invalid command type"}
+        if string is None:
+            return {"success": False, "message": "Missing string parameter"}
         
-        return await self.set_valve_position(command=cmd_str)
+        # 将 string 参数转换为 command 参数
+        if string.upper() in ["ON", "OPEN"]:
+            command = "OPEN"
+        elif string.upper() in ["OFF", "CLOSED"]:
+            command = "CLOSED"
+        else:
+            command = string
+        
+        return await self.set_valve_position(command=command)
 
     def toggle(self):
         """切换阀门状态"""
@@ -129,19 +148,6 @@ class VirtualSolenoidValve:
         """检查阀门是否关闭"""
         return not self._is_open
 
-    def get_state(self) -> dict:
-        """获取阀门完整状态"""
-        return {
-            "device_id": self.device_id,
-            "port": self.port,
-            "voltage": self.voltage,
-            "response_time": self.response_time,
-            "is_open": self._is_open,
-            "valve_state": self._valve_state,
-            "status": self._status,
-            "position": self.get_valve_position()
-        }
-
     async def reset(self):
         """重置阀门到关闭状态"""
         return await self.close()

unilabos/devices/virtual/virtual_solid_dispenser.py

@@ -0,0 +1,389 @@
+import asyncio
+import logging
+import re
+from typing import Dict, Any, Optional
+
+class VirtualSolidDispenser:
+    """
+    虚拟固体粉末加样器 - 用于处理 Add Protocol 中的固体试剂添加 ⚗️
+    
+    特点：
+    - 高兼容性：缺少参数不报错 ✅
+    - 智能识别：自动查找固体试剂瓶 🔍
+    - 简单反馈：成功/失败 + 消息 📊
+    """
+    
+    def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
+        self.device_id = device_id or "virtual_solid_dispenser"
+        self.config = config or {}
+        
+        # 设备参数
+        self.max_capacity = float(self.config.get('max_capacity', 100.0))  # 最大加样量 (g)
+        self.precision = float(self.config.get('precision', 0.001))  # 精度 (g)
+        
+        # 状态变量
+        self._status = "Idle"
+        self._current_reagent = ""
+        self._dispensed_amount = 0.0
+        self._total_operations = 0
+        
+        self.logger = logging.getLogger(f"VirtualSolidDispenser.{self.device_id}")
+        
+        print(f"⚗️ === 虚拟固体分配器 {self.device_id} 创建成功! === ✨")
+        print(f"📊 设备规格: 最大容量 {self.max_capacity}g | 精度 {self.precision}g 🎯")
+    
+    async def initialize(self) -> bool:
+        """初始化固体加样器 🚀"""
+        self.logger.info(f"🔧 初始化固体分配器 {self.device_id} ✨")
+        self._status = "Ready"
+        self._current_reagent = ""
+        self._dispensed_amount = 0.0
+        
+        self.logger.info(f"✅ 固体分配器 {self.device_id} 初始化完成 ⚗️")
+        return True
+    
+    async def cleanup(self) -> bool:
+        """清理固体加样器 🧹"""
+        self.logger.info(f"🧹 清理固体分配器 {self.device_id} 🔚")
+        self._status = "Idle"
+        
+        self.logger.info(f"✅ 固体分配器 {self.device_id} 清理完成 💤")
+        return True
+    
+    def parse_mass_string(self, mass_str: str) -> float:
+        """
+        解析质量字符串为数值 (g) ⚖️
+        
+        支持格式: "2.9 g", "19.3g", "4.5 mg", "1.2 kg" 等
+        """
+        if not mass_str or not isinstance(mass_str, str):
+            return 0.0
+        
+        # 移除空格并转小写
+        mass_clean = mass_str.strip().lower()
+        
+        # 正则匹配数字和单位
+        pattern = r'(\d+(?:\.\d+)?)\s*([a-z]*)'
+        match = re.search(pattern, mass_clean)
+        
+        if not match:
+            self.logger.debug(f"🔍 无法解析质量字符串: {mass_str}")
+            return 0.0
+        
+        try:
+            value = float(match.group(1))
+            unit = match.group(2) or 'g'  # 默认单位 g
+            
+            # 单位转换为 g
+            unit_multipliers = {
+                'g': 1.0,
+                'gram': 1.0,
+                'grams': 1.0,
+                'mg': 0.001,
+                'milligram': 0.001,
+                'milligrams': 0.001,
+                'kg': 1000.0,
+                'kilogram': 1000.0,
+                'kilograms': 1000.0,
+                'μg': 0.000001,
+                'ug': 0.000001,
+                'microgram': 0.000001,
+                'micrograms': 0.000001,
+            }
+            
+            multiplier = unit_multipliers.get(unit, 1.0)
+            result = value * multiplier
+            
+            self.logger.debug(f"⚖️ 质量解析: {mass_str} → {result:.6f}g (原值: {value} {unit})")
+            return result
+        
+        except (ValueError, TypeError):
+            self.logger.warning(f"⚠️ 无法解析质量字符串: {mass_str}")
+            return 0.0
+    
+    def parse_mol_string(self, mol_str: str) -> float:
+        """
+        解析摩尔数字符串为数值 (mol) 🧮
+        
+        支持格式: "0.12 mol", "16.2 mmol", "25.2mmol" 等
+        """
+        if not mol_str or not isinstance(mol_str, str):
+            return 0.0
+        
+        # 移除空格并转小写
+        mol_clean = mol_str.strip().lower()
+        
+        # 正则匹配数字和单位
+        pattern = r'(\d+(?:\.\d+)?)\s*(m?mol)'
+        match = re.search(pattern, mol_clean)
+        
+        if not match:
+            self.logger.debug(f"🔍 无法解析摩尔数字符串: {mol_str}")
+            return 0.0
+        
+        try:
+            value = float(match.group(1))
+            unit = match.group(2)
+            
+            # 单位转换为 mol
+            if unit == 'mmol':
+                result = value * 0.001
+            else:  # mol
+                result = value
+            
+            self.logger.debug(f"🧮 摩尔数解析: {mol_str} → {result:.6f}mol (原值: {value} {unit})")
+            return result
+        
+        except (ValueError, TypeError):
+            self.logger.warning(f"⚠️ 无法解析摩尔数字符串: {mol_str}")
+            return 0.0
+    
+    def find_solid_reagent_bottle(self, reagent_name: str) -> str:
+        """
+        查找固体试剂瓶 🔍
+        
+        这是一个简化版本，实际使用时应该连接到系统的设备图
+        """
+        if not reagent_name:
+            self.logger.debug(f"🔍 未指定试剂名称，使用默认瓶")
+            return "unknown_solid_bottle"
+        
+        # 可能的固体试剂瓶命名模式
+        possible_names = [
+            f"solid_bottle_{reagent_name}",
+            f"reagent_solid_{reagent_name}",
+            f"powder_{reagent_name}",
+            f"{reagent_name}_solid",
+            f"{reagent_name}_powder",
+            f"solid_{reagent_name}",
+        ]
+        
+        # 这里简化处理，实际应该查询设备图
+        selected_bottle = possible_names[0]
+        self.logger.debug(f"🔍 为试剂 {reagent_name} 选择试剂瓶: {selected_bottle}")
+        return selected_bottle
+    
+    async def add_solid(
+        self,
+        vessel: str,
+        reagent: str,
+        mass: str = "",
+        mol: str = "",
+        purpose: str = "",
+        **kwargs  # 兼容额外参数
+    ) -> Dict[str, Any]:
+        """
+        添加固体试剂的主要方法 ⚗️
+        
+        Args:
+            vessel: 目标容器
+            reagent: 试剂名称
+            mass: 质量字符串 (如 "2.9 g")
+            mol: 摩尔数字符串 (如 "0.12 mol")
+            purpose: 添加目的
+            **kwargs: 其他兼容参数
+        
+        Returns:
+            Dict: 操作结果
+        """
+        try:
+            self.logger.info(f"⚗️ === 开始固体加样操作 === ✨")
+            self.logger.info(f"  🥽 目标容器: {vessel}")
+            self.logger.info(f"  🧪 试剂: {reagent}")
+            self.logger.info(f"  ⚖️ 质量: {mass}")
+            self.logger.info(f"  🧮 摩尔数: {mol}")
+            self.logger.info(f"  📝 目的: {purpose}")
+            
+            # 参数验证 - 宽松处理
+            if not vessel:
+                vessel = "main_reactor"  # 默认容器
+                self.logger.warning(f"⚠️ 未指定容器，使用默认容器: {vessel} 🏠")
+            
+            if not reagent:
+                error_msg = "❌ 错误: 必须指定试剂名称"
+                self.logger.error(error_msg)
+                return {
+                    "success": False,
+                    "message": error_msg,
+                    "return_info": "missing_reagent"
+                }
+            
+            # 解析质量和摩尔数
+            mass_value = self.parse_mass_string(mass)
+            mol_value = self.parse_mol_string(mol)
+            
+            self.logger.info(f"📊 解析结果 - 质量: {mass_value:.6f}g | 摩尔数: {mol_value:.6f}mol")
+            
+            # 确定实际加样量
+            if mass_value > 0:
+                actual_amount = mass_value
+                amount_unit = "g"
+                amount_emoji = "⚖️"
+                self.logger.info(f"⚖️ 按质量加样: {actual_amount:.6f} {amount_unit}")
+            elif mol_value > 0:
+                # 简化处理：假设分子量为100 g/mol
+                assumed_mw = 100.0
+                actual_amount = mol_value * assumed_mw
+                amount_unit = "g (from mol)"
+                amount_emoji = "🧮"
+                self.logger.info(f"🧮 按摩尔数加样: {mol_value:.6f} mol → {actual_amount:.6f} g (假设分子量 {assumed_mw})")
+            else:
+                # 没有指定量，使用默认值
+                actual_amount = 1.0
+                amount_unit = "g (default)"
+                amount_emoji = "🎯"
+                self.logger.warning(f"⚠️ 未指定质量或摩尔数，使用默认值: {actual_amount} {amount_unit} 🎯")
+            
+            # 检查容量限制
+            if actual_amount > self.max_capacity:
+                error_msg = f"❌ 错误: 请求量 {actual_amount:.3f}g 超过最大容量 {self.max_capacity}g"
+                self.logger.error(error_msg)
+                return {
+                    "success": False,
+                    "message": error_msg,
+                    "return_info": "exceeds_capacity"
+                }
+            
+            # 查找试剂瓶
+            reagent_bottle = self.find_solid_reagent_bottle(reagent)
+            self.logger.info(f"🔍 使用试剂瓶: {reagent_bottle}")
+            
+            # 模拟加样过程
+            self._status = "Dispensing"
+            self._current_reagent = reagent
+            
+            # 计算操作时间 (基于质量)
+            operation_time = max(0.5, actual_amount * 0.1)  # 每克0.1秒，最少0.5秒
+            
+            self.logger.info(f"🚀 开始加样，预计时间: {operation_time:.1f}秒 ⏱️")
+            
+            # 显示进度的模拟
+            steps = max(3, int(operation_time))
+            step_time = operation_time / steps
+            
+            for i in range(steps):
+                progress = (i + 1) / steps * 100
+                await asyncio.sleep(step_time)
+                if i % 2 == 0:  # 每隔一步显示进度
+                    self.logger.debug(f"📊 加样进度: {progress:.0f}% | {amount_emoji} 正在分配 {reagent}...")
+            
+            # 更新状态
+            self._dispensed_amount = actual_amount
+            self._total_operations += 1
+            self._status = "Ready"
+            
+            # 成功结果
+            success_message = f"✅ 成功添加 {reagent} {actual_amount:.6f} {amount_unit} 到 {vessel}"
+            
+            self.logger.info(f"🎉 === 固体加样完成 === ✨")
+            self.logger.info(f"📊 操作结果:")
+            self.logger.info(f"  ✅ {success_message}")
+            self.logger.info(f"  🧪 试剂瓶: {reagent_bottle}")
+            self.logger.info(f"  ⏱️ 用时: {operation_time:.1f}秒")
+            self.logger.info(f"  🎯 总操作次数: {self._total_operations} 🏁")
+            
+            return {
+                "success": True,
+                "message": success_message,
+                "return_info": f"dispensed_{actual_amount:.6f}g",
+                "dispensed_amount": actual_amount,
+                "reagent": reagent,
+                "vessel": vessel
+            }
+            
+        except Exception as e:
+            error_message = f"❌ 固体加样失败: {str(e)} 💥"
+            self.logger.error(error_message)
+            self._status = "Error"
+            
+            return {
+                "success": False,
+                "message": error_message,
+                "return_info": "operation_failed"
+            }
+    
+    # 状态属性
+    @property
+    def status(self) -> str:
+        return self._status
+    
+    @property
+    def current_reagent(self) -> str:
+        return self._current_reagent
+    
+    @property
+    def dispensed_amount(self) -> float:
+        return self._dispensed_amount
+    
+    @property
+    def total_operations(self) -> int:
+        return self._total_operations
+    
+    def get_device_info(self) -> Dict[str, Any]:
+        """获取设备状态信息 📊"""
+        info = {
+            "device_id": self.device_id,
+            "status": self._status,
+            "current_reagent": self._current_reagent,
+            "last_dispensed_amount": self._dispensed_amount,
+            "total_operations": self._total_operations,
+            "max_capacity": self.max_capacity,
+            "precision": self.precision
+        }
+        
+        self.logger.debug(f"📊 设备信息: 状态={self._status}, 试剂={self._current_reagent}, 加样量={self._dispensed_amount:.6f}g")
+        return info
+    
+    def __str__(self):
+        status_emoji = "✅" if self._status == "Ready" else "🔄" if self._status == "Dispensing" else "❌" if self._status == "Error" else "🏠"
+        return f"⚗️ VirtualSolidDispenser({status_emoji} {self.device_id}: {self._status}, 最后加样 {self._dispensed_amount:.3f}g)"
+
+
+# 测试函数
+async def test_solid_dispenser():
+    """测试固体加样器 🧪"""
+    print("⚗️ === 固体加样器测试开始 === 🧪")
+    
+    dispenser = VirtualSolidDispenser("test_dispenser")
+    await dispenser.initialize()
+    
+    # 测试1: 按质量加样
+    print(f"\n🧪 测试1: 按质量加样...")
+    result1 = await dispenser.add_solid(
+        vessel="main_reactor",
+        reagent="magnesium",
+        mass="2.9 g"
+    )
+    print(f"📊 测试1结果: {result1}")
+    
+    # 测试2: 按摩尔数加样
+    print(f"\n🧮 测试2: 按摩尔数加样...")
+    result2 = await dispenser.add_solid(
+        vessel="main_reactor",
+        reagent="sodium_nitrite",
+        mol="0.28 mol"
+    )
+    print(f"📊 测试2结果: {result2}")
+    
+    # 测试3: 缺少参数
+    print(f"\n⚠️ 测试3: 缺少参数测试...")
+    result3 = await dispenser.add_solid(
+        reagent="test_compound"
+    )
+    print(f"📊 测试3结果: {result3}")
+    
+    # 测试4: 超容量测试
+    print(f"\n❌ 测试4: 超容量测试...")
+    result4 = await dispenser.add_solid(
+        vessel="main_reactor",
+        reagent="heavy_compound",
+        mass="150 g"  # 超过100g限制
+    )
+    print(f"📊 测试4结果: {result4}")
+    
+    print(f"\n📊 最终设备信息: {dispenser.get_device_info()}")
+    print(f"✅ === 测试完成 === 🎉")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_solid_dispenser())

unilabos/devices/virtual/virtual_stirrer.py

@@ -4,7 +4,7 @@ import time as time_module
 from typing import Dict, Any
 
 class VirtualStirrer:
-    """Virtual stirrer device for StirProtocol testing - 功能完整版"""
+    """Virtual stirrer device for StirProtocol testing - 功能完整版 🌪️"""
     
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -30,45 +30,69 @@ class VirtualStirrer:
         for key, value in kwargs.items():
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
+        
+        print(f"🌪️ === 虚拟搅拌器 {self.device_id} 已创建 === ✨")
+        print(f"🔧 速度范围: {self._min_speed} ~ {self._max_speed} RPM | 📱 端口: {self.port}")
     
     async def initialize(self) -> bool:
-        """Initialize virtual stirrer"""
-        self.logger.info(f"Initializing virtual stirrer {self.device_id}")
+        """Initialize virtual stirrer 🚀"""
+        self.logger.info(f"🔧 初始化虚拟搅拌器 {self.device_id} ✨")
         
         # 初始化状态信息
         self.data.update({
-            "status": "Idle",
+            "status": "🏠 待机中",
             "operation_mode": "Idle",          # 操作模式: Idle, Stirring, Settling, Completed, Error
             "current_vessel": "",              # 当前搅拌的容器
             "current_speed": 0.0,              # 当前搅拌速度
             "is_stirring": False,              # 是否正在搅拌
             "remaining_time": 0.0,             # 剩余时间
         })
+        
+        self.logger.info(f"✅ 搅拌器 {self.device_id} 初始化完成 🌪️")
+        self.logger.info(f"📊 设备规格: 速度范围 {self._min_speed} ~ {self._max_speed} RPM")
         return True
     
     async def cleanup(self) -> bool:
-        """Cleanup virtual stirrer"""
-        self.logger.info(f"Cleaning up virtual stirrer {self.device_id}")
+        """Cleanup virtual stirrer 🧹"""
+        self.logger.info(f"🧹 清理虚拟搅拌器 {self.device_id} 🔚")
+        
         self.data.update({
-            "status": "Offline",
+            "status": "💤 离线",
             "operation_mode": "Offline",
             "current_vessel": "",
             "current_speed": 0.0,
             "is_stirring": False,
             "remaining_time": 0.0,
         })
+        
+        self.logger.info(f"✅ 搅拌器 {self.device_id} 清理完成 💤")
         return True
     
-    async def stir(self, stir_time: float, stir_speed: float, settling_time: float) -> bool:
-        """Execute stir action - 定时搅拌 + 沉降"""
-        self.logger.info(f"Stir: speed={stir_speed} RPM, time={stir_time}s, settling={settling_time}s")
+    async def stir(self, stir_time: float, stir_speed: float, settling_time: float, **kwargs) -> bool:
+        """Execute stir action - 定时搅拌 + 沉降 🌪️"""
+        
+        # 🔧 类型转换 - 确保所有参数都是数字类型
+        try:
+            stir_time = float(stir_time)
+            stir_speed = float(stir_speed)
+            settling_time = float(settling_time)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换失败: stir_time={stir_time}, stir_speed={stir_speed}, settling_time={settling_time}, error={e}"
+            self.logger.error(f"❌ {error_msg}")
+            self.data.update({
+                "status": f"❌ 错误: {error_msg}",
+                "operation_mode": "Error"
+            })
+            return False
+        
+        self.logger.info(f"🌪️ 开始搅拌操作: 速度 {stir_speed} RPM | 时间 {stir_time}s | 沉降 {settling_time}s")
         
         # 验证参数
         if stir_speed > self._max_speed or stir_speed < self._min_speed:
-            error_msg = f"搅拌速度 {stir_speed} RPM 超出范围 ({self._min_speed} - {self._max_speed} RPM)"
-            self.logger.error(error_msg)
+            error_msg = f"🌪️ 搅拌速度 {stir_speed} RPM 超出范围 ({self._min_speed} - {self._max_speed} RPM) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: 速度超出范围",
                 "operation_mode": "Error"
             })
             return False
@@ -77,8 +101,10 @@ class VirtualStirrer:
         start_time = time_module.time()
         total_stir_time = stir_time
         
+        self.logger.info(f"🚀 开始搅拌阶段: {stir_speed} RPM × {total_stir_time}s ⏱️")
+        
         self.data.update({
-            "status": f"搅拌中: {stir_speed} RPM | 剩余: {total_stir_time:.0f}s",
+            "status": f"🌪️ 搅拌中: {stir_speed} RPM | ⏰ 剩余: {total_stir_time:.0f}s",
             "operation_mode": "Stirring",
             "current_speed": stir_speed,
             "is_stirring": True,
@@ -86,30 +112,41 @@ class VirtualStirrer:
         })
         
         # 搅拌过程 - 实时更新剩余时间
+        last_logged_time = 0
         while True:
             current_time = time_module.time()
             elapsed = current_time - start_time
             remaining = max(0, total_stir_time - elapsed)
+            progress = (elapsed / total_stir_time) * 100 if total_stir_time > 0 else 100
             
             # 更新状态
             self.data.update({
                 "remaining_time": remaining,
-                "status": f"搅拌中: {stir_speed} RPM | 剩余: {remaining:.0f}s"
+                "status": f"🌪️ 搅拌中: {stir_speed} RPM | ⏰ 剩余: {remaining:.0f}s"
             })
             
+            # 进度日志（每25%打印一次）
+            if progress >= 25 and int(progress) % 25 == 0 and int(progress) != last_logged_time:
+                self.logger.info(f"📊 搅拌进度: {progress:.0f}% | 🌪️ {stir_speed} RPM | ⏰ 剩余: {remaining:.0f}s ✨")
+                last_logged_time = int(progress)
+            
             # 搅拌时间到了
             if remaining <= 0:
                 break
             
             await asyncio.sleep(1.0)
         
+        self.logger.info(f"✅ 搅拌阶段完成! 🌪️ {stir_speed} RPM × {stir_time}s")
+        
         # === 第二阶段：沉降（如果需要）===
         if settling_time > 0:
             start_settling_time = time_module.time()
             total_settling_time = settling_time
             
+            self.logger.info(f"🛑 开始沉降阶段: 停止搅拌 × {total_settling_time}s ⏱️")
+            
             self.data.update({
-                "status": f"沉降中: 停止搅拌 | 剩余: {total_settling_time:.0f}s",
+                "status": f"🛑 沉降中: 停止搅拌 | ⏰ 剩余: {total_settling_time:.0f}s",
                 "operation_mode": "Settling",
                 "current_speed": 0.0,
                 "is_stirring": False,
@@ -117,52 +154,87 @@ class VirtualStirrer:
             })
             
             # 沉降过程 - 实时更新剩余时间
+            last_logged_settling = 0
             while True:
                 current_time = time_module.time()
                 elapsed = current_time - start_settling_time
                 remaining = max(0, total_settling_time - elapsed)
+                progress = (elapsed / total_settling_time) * 100 if total_settling_time > 0 else 100
                 
                 # 更新状态
                 self.data.update({
                     "remaining_time": remaining,
-                    "status": f"沉降中: 停止搅拌 | 剩余: {remaining:.0f}s"
+                    "status": f"🛑 沉降中: 停止搅拌 | ⏰ 剩余: {remaining:.0f}s"
                 })
                 
+                # 进度日志（每25%打印一次）
+                if progress >= 25 and int(progress) % 25 == 0 and int(progress) != last_logged_settling:
+                    self.logger.info(f"📊 沉降进度: {progress:.0f}% | 🛑 静置中 | ⏰ 剩余: {remaining:.0f}s ✨")
+                    last_logged_settling = int(progress)
+                
                 # 沉降时间到了
                 if remaining <= 0:
                     break
                 
                 await asyncio.sleep(1.0)
+            
+            self.logger.info(f"✅ 沉降阶段完成! 🛑 静置 {settling_time}s")
         
         # === 操作完成 ===
-        settling_info = f" | 沉降: {settling_time:.0f}s" if settling_time > 0 else ""
+        settling_info = f" | 🛑 沉降: {settling_time:.0f}s" if settling_time > 0 else ""
+        
         self.data.update({
-            "status": f"完成: 搅拌 {stir_speed} RPM, {stir_time:.0f}s{settling_info}",
+            "status": f"✅ 完成: 🌪️ 搅拌 {stir_speed} RPM × {stir_time:.0f}s{settling_info}",
             "operation_mode": "Completed",
             "current_speed": 0.0,
             "is_stirring": False,
             "remaining_time": 0.0,
         })
         
-        self.logger.info(f"Stir completed: {stir_speed} RPM for {stir_time}s + settling {settling_time}s")
+        self.logger.info(f"🎉 搅拌操作完成! ✨")
+        self.logger.info(f"📊 操作总结:")
+        self.logger.info(f"  🌪️ 搅拌: {stir_speed} RPM × {stir_time}s")
+        if settling_time > 0:
+            self.logger.info(f"  🛑 沉降: {settling_time}s")
+        self.logger.info(f"  ⏱️ 总用时: {(stir_time + settling_time):.0f}s 🏁")
+        
         return True
     
-    async def start_stir(self, vessel: str, stir_speed: float, purpose: str) -> bool:
-        """Start stir action - 开始持续搅拌"""
-        self.logger.info(f"StartStir: vessel={vessel}, speed={stir_speed} RPM, purpose={purpose}")
+    async def start_stir(self, vessel: str, stir_speed: float, purpose: str = "") -> bool:
+        """Start stir action - 开始持续搅拌 🔄"""
         
-        # 验证参数
-        if stir_speed > self._max_speed or stir_speed < self._min_speed:
-            error_msg = f"搅拌速度 {stir_speed} RPM 超出范围 ({self._min_speed} - {self._max_speed} RPM)"
-            self.logger.error(error_msg)
+        # 🔧 类型转换
+        try:
+            stir_speed = float(stir_speed)
+            vessel = str(vessel)
+            purpose = str(purpose)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换错误: {str(e)}"
+            self.logger.error(f"❌ {error_msg}")
             self.data.update({
-                "status": f"Error: {error_msg}",
+                "status": f"❌ 错误: {error_msg}",
                 "operation_mode": "Error"
             })
             return False
         
+        self.logger.info(f"🔄 启动持续搅拌: {vessel} | 🌪️ {stir_speed} RPM")
+        if purpose:
+            self.logger.info(f"📝 搅拌目的: {purpose}")
+        
+        # 验证参数
+        if stir_speed > self._max_speed or stir_speed < self._min_speed:
+            error_msg = f"🌪️ 搅拌速度 {stir_speed} RPM 超出范围 ({self._min_speed} - {self._max_speed} RPM) ⚠️"
+            self.logger.error(f"❌ {error_msg}")
+            self.data.update({
+                "status": f"❌ 错误: 速度超出范围",
+                "operation_mode": "Error"
+            })
+            return False
+        
+        purpose_info = f" | 📝 {purpose}" if purpose else ""
+        
         self.data.update({
-            "status": f"启动: 持续搅拌 {vessel} at {stir_speed} RPM | {purpose}",
+            "status": f"🔄 启动: 持续搅拌 {vessel} | 🌪️ {stir_speed} RPM{purpose_info}",
             "operation_mode": "Stirring",
             "current_vessel": vessel,
             "current_speed": stir_speed,
@@ -170,16 +242,28 @@ class VirtualStirrer:
             "remaining_time": -1.0,  # -1 表示持续运行
         })
         
+        self.logger.info(f"✅ 持续搅拌已启动! 🌪️ {stir_speed} RPM × ♾️ 🚀")
         return True
     
     async def stop_stir(self, vessel: str) -> bool:
-        """Stop stir action - 停止搅拌"""
-        self.logger.info(f"StopStir: vessel={vessel}")
+        """Stop stir action - 停止搅拌 🛑"""
+        
+        # 🔧 类型转换
+        try:
+            vessel = str(vessel)
+        except (ValueError, TypeError) as e:
+            error_msg = f"参数类型转换错误: {str(e)}"
+            self.logger.error(f"❌ {error_msg}")
+            return False
         
         current_speed = self.data.get("current_speed", 0.0)
         
+        self.logger.info(f"🛑 停止搅拌: {vessel}")
+        if current_speed > 0:
+            self.logger.info(f"🌪️ 之前搅拌速度: {current_speed} RPM")
+        
         self.data.update({
-            "status": f"已停止: {vessel} 搅拌停止 | 之前速度: {current_speed} RPM",
+            "status": f"🛑 已停止: {vessel} 搅拌停止 | 之前速度: {current_speed} RPM",
             "operation_mode": "Stopped",
             "current_vessel": "",
             "current_speed": 0.0,
@@ -187,12 +271,13 @@ class VirtualStirrer:
             "remaining_time": 0.0,
         })
         
+        self.logger.info(f"✅ 搅拌器已停止 {vessel} 的搅拌操作 🏁")
         return True
     
     # 状态属性
     @property
     def status(self) -> str:
-        return self.data.get("status", "Idle")
+        return self.data.get("status", "🏠 待机中")
     
     @property
     def operation_mode(self) -> str:
@@ -212,4 +297,33 @@ class VirtualStirrer:
     
     @property
     def remaining_time(self) -> float:
-        return self.data.get("remaining_time", 0.0)
+        return self.data.get("remaining_time", 0.0)
+    
+    @property
+    def max_speed(self) -> float:
+        return self._max_speed
+    
+    @property
+    def min_speed(self) -> float:
+        return self._min_speed
+    
+    def get_device_info(self) -> Dict[str, Any]:
+        """获取设备状态信息 📊"""
+        info = {
+            "device_id": self.device_id,
+            "status": self.status,
+            "operation_mode": self.operation_mode,
+            "current_vessel": self.current_vessel,
+            "current_speed": self.current_speed,
+            "is_stirring": self.is_stirring,
+            "remaining_time": self.remaining_time,
+            "max_speed": self._max_speed,
+            "min_speed": self._min_speed
+        }
+        
+        self.logger.debug(f"📊 设备信息: 模式={self.operation_mode}, 速度={self.current_speed} RPM, 搅拌={self.is_stirring}")
+        return info
+    
+    def __str__(self):
+        status_emoji = "✅" if self.operation_mode == "Idle" else "🌪️" if self.operation_mode == "Stirring" else "🛑" if self.operation_mode == "Settling" else "❌"
+        return f"🌪️ VirtualStirrer({status_emoji} {self.device_id}: {self.operation_mode}, {self.current_speed} RPM)"

unilabos/devices/virtual/virtual_transferpump.py

@@ -12,7 +12,7 @@ class VirtualPumpMode(Enum):
 
 
 class VirtualTransferPump:
-    """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件"""
+    """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件 🚰"""
     
     def __init__(self, device_id: str = None, config: dict = None, **kwargs):
         """
@@ -42,20 +42,31 @@ class VirtualTransferPump:
         self._max_velocity = 5.0  # float 
         self._current_volume = 0.0  # float
 
+        # 🚀 新增：快速模式设置 - 大幅缩短执行时间
+        self._fast_mode = True  # 是否启用快速模式
+        self._fast_move_time = 1.0  # 快速移动时间（秒）
+        self._fast_dispense_time = 1.0  # 快速喷射时间（秒）
+
         self.logger = logging.getLogger(f"VirtualTransferPump.{self.device_id}")
+        
+        print(f"🚰 === 虚拟转移泵 {self.device_id} 已创建 === ✨")
+        print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
+        print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
     
     async def initialize(self) -> bool:
-        """初始化虚拟泵"""
-        self.logger.info(f"Initializing virtual pump {self.device_id}")
+        """初始化虚拟泵 🚀"""
+        self.logger.info(f"🔧 初始化虚拟转移泵 {self.device_id} ✨")
         self._status = "Idle"
         self._position = 0.0
         self._current_volume = 0.0
+        self.logger.info(f"✅ 转移泵 {self.device_id} 初始化完成 🚰")
         return True
     
     async def cleanup(self) -> bool:
-        """清理虚拟泵"""
-        self.logger.info(f"Cleaning up virtual pump {self.device_id}")
+        """清理虚拟泵 🧹"""
+        self.logger.info(f"🧹 清理虚拟转移泵 {self.device_id} 🔚")
         self._status = "Idle"
+        self.logger.info(f"✅ 转移泵 {self.device_id} 清理完成 💤")
         return True
     
     # 基本属性
@@ -65,12 +76,12 @@ class VirtualTransferPump:
     
     @property
     def position(self) -> float:
-        """当前柱塞位置 (ml)"""
+        """当前柱塞位置 (ml) 📍"""
         return self._position
     
     @property
     def current_volume(self) -> float:
-        """当前注射器中的体积 (ml)"""
+        """当前注射器中的体积 (ml) 💧"""
         return self._current_volume
     
     @property
@@ -82,22 +93,50 @@ class VirtualTransferPump:
         return self._transfer_rate
 
     def set_max_velocity(self, velocity: float):
-        """设置最大速度 (ml/s)"""
+        """设置最大速度 (ml/s) 🌊"""
         self._max_velocity = max(0.1, min(50.0, velocity))  # 限制在合理范围内
-        self.logger.info(f"Set max velocity to {self._max_velocity} ml/s")
+        self.logger.info(f"🌊 设置最大速度为 {self._max_velocity} mL/s")
     
     def get_status(self) -> str:
-        """获取泵状态"""
+        """获取泵状态 📋"""
         return self._status
     
     async def _simulate_operation(self, duration: float):
-        """模拟操作延时"""
+        """模拟操作延时 ⏱️"""
         self._status = "Busy"
         await asyncio.sleep(duration)
         self._status = "Idle"
     
     def _calculate_duration(self, volume: float, velocity: float = None) -> float:
-        """计算操作持续时间"""
+        """
+        计算操作持续时间 ⏰
+        🚀 快速模式：保留计算逻辑用于日志显示，但实际使用固定的快速时间
+        """
+        if velocity is None:
+            velocity = self._max_velocity
+        
+        # 📊 计算理论时间（用于日志显示）
+        theoretical_duration = abs(volume) / velocity
+        
+        # 🚀 如果启用快速模式，使用固定的快速时间
+        if self._fast_mode:
+            # 根据操作类型选择快速时间
+            if abs(volume) > 0.1:  # 大于0.1mL的操作
+                actual_duration = self._fast_move_time
+            else:  # 很小的操作
+                actual_duration = 0.5
+            
+            self.logger.debug(f"⚡ 快速模式: 理论时间 {theoretical_duration:.2f}s → 实际时间 {actual_duration:.2f}s")
+            return actual_duration
+        else:
+            # 正常模式使用理论时间
+            return theoretical_duration
+    
+    def _calculate_display_duration(self, volume: float, velocity: float = None) -> float:
+        """
+        计算显示用的持续时间（用于日志） 📊
+        这个函数返回理论计算时间，用于日志显示
+        """
         if velocity is None:
             velocity = self._max_velocity
         return abs(volume) / velocity
@@ -105,7 +144,7 @@ class VirtualTransferPump:
     # 新的set_position方法 - 专门用于SetPumpPosition动作
     async def set_position(self, position: float, max_velocity: float = None):
         """
-        移动到绝对位置 - 专门用于SetPumpPosition动作
+        移动到绝对位置 - 专门用于SetPumpPosition动作 🎯
         
         Args:
             position (float): 目标位置 (ml)
@@ -122,56 +161,107 @@ class VirtualTransferPump:
             # 限制位置在有效范围内
             target_position = max(0.0, min(float(self.max_volume), target_position))
             
-            # 计算移动距离和时间
+            # 计算移动距离
             volume_to_move = abs(target_position - self._position)
-            duration = self._calculate_duration(volume_to_move, velocity)
             
-            self.logger.info(f"SET_POSITION: Moving to {target_position} ml (current: {self._position} ml), velocity: {velocity} ml/s")
+            # 📊 计算显示用的时间（用于日志）
+            display_duration = self._calculate_display_duration(volume_to_move, velocity)
             
-            # 模拟移动过程
-            start_position = self._position
-            steps = 10 if duration > 0.1 else 1  # 如果移动距离很小，只用1步
-            step_duration = duration / steps if steps > 1 else duration
+            # ⚡ 计算实际执行时间（快速模式）
+            actual_duration = self._calculate_duration(volume_to_move, velocity)
             
-            for i in range(steps + 1):
-                # 计算当前位置和进度
-                progress = (i / steps) * 100 if steps > 0 else 100
-                current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
+            # 🎯 确定操作类型和emoji
+            if target_position > self._position:
+                operation_type = "吸液"
+                operation_emoji = "📥"
+            elif target_position < self._position:
+                operation_type = "排液"
+                operation_emoji = "📤"
+            else:
+                operation_type = "保持"
+                operation_emoji = "📍"
+            
+            self.logger.info(f"🎯 SET_POSITION: {operation_type} {operation_emoji}")
+            self.logger.info(f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)")
+            self.logger.info(f"  🌊 速度: {velocity:.2f} mL/s")
+            self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
+            
+            if self._fast_mode:
+                self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
+            
+            # 🚀 模拟移动过程
+            if volume_to_move > 0.01:  # 只有当移动距离足够大时才显示进度
+                start_position = self._position
+                steps = 5 if actual_duration > 0.5 else 2  # 根据实际时间调整步数
+                step_duration = actual_duration / steps
                 
-                # 更新状态
-                self._status = "Moving" if i < steps else "Idle"
-                self._position = current_pos
-                self._current_volume = current_pos
+                self.logger.info(f"🚀 开始{operation_type}... {operation_emoji}")
                 
-                # 等待一小步时间
-                if i < steps and step_duration > 0:
-                    await asyncio.sleep(step_duration)
+                for i in range(steps + 1):
+                    # 计算当前位置和进度
+                    progress = (i / steps) * 100 if steps > 0 else 100
+                    current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
+                    
+                    # 更新状态
+                    if i < steps:
+                        self._status = f"{operation_type}中"
+                        status_emoji = "🔄"
+                    else:
+                        self._status = "Idle"
+                        status_emoji = "✅"
+                    
+                    self._position = current_pos
+                    self._current_volume = current_pos
+                    
+                    # 显示进度（每25%或最后一步）
+                    if i == 0:
+                        self.logger.debug(f"  🔄 {operation_type}开始: {progress:.0f}%")
+                    elif progress >= 50 and i == steps // 2:
+                        self.logger.debug(f"  🔄 {operation_type}进度: {progress:.0f}%")
+                    elif i == steps:
+                        self.logger.info(f"  ✅ {operation_type}完成: {progress:.0f}% | 当前位置: {current_pos:.2f}mL")
+                    
+                    # 等待一小步时间
+                    if i < steps and step_duration > 0:
+                        await asyncio.sleep(step_duration)
+            else:
+                # 移动距离很小，直接完成
+                self._position = target_position
+                self._current_volume = target_position
+                self.logger.info(f"  📍 微调完成: {target_position:.2f}mL")
         
             # 确保最终位置准确
             self._position = target_position
             self._current_volume = target_position
             self._status = "Idle"
             
-            self.logger.info(f"SET_POSITION: Reached position {self._position} ml, current volume: {self._current_volume} ml")
+            # 📊 最终状态日志
+            if volume_to_move > 0.01:
+                self.logger.info(f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
             
             # 返回符合action定义的结果
             return {
                 "success": True,
-                "message": f"Successfully moved to position {self._position} ml"
+                "message": f"✅ 成功移动到位置 {self._position:.2f}mL ({operation_type})",
+                "final_position": self._position,
+                "final_volume": self._current_volume,
+                "operation_type": operation_type
             }
             
         except Exception as e:
-            error_msg = f"Failed to set position: {str(e)}"
+            error_msg = f"❌ 设置位置失败: {str(e)}"
             self.logger.error(error_msg)
             return {
                 "success": False,
-                "message": error_msg
+                "message": error_msg,
+                "final_position": self._position,
+                "final_volume": self._current_volume
             }
     
     # 其他泵操作方法
     async def pull_plunger(self, volume: float, velocity: float = None):
         """
-        拉取柱塞（吸液）
+        拉取柱塞（吸液） 📥
         
         Args:
             volume (float): 要拉取的体积 (ml)
@@ -181,23 +271,29 @@ class VirtualTransferPump:
         actual_volume = new_position - self._position
         
         if actual_volume <= 0:
-            self.logger.warning("Cannot pull - already at maximum volume")
+            self.logger.warning("⚠️ 无法吸液 - 已达到最大容量")
             return
         
-        duration = self._calculate_duration(actual_volume, velocity)
+        display_duration = self._calculate_display_duration(actual_volume, velocity)
+        actual_duration = self._calculate_duration(actual_volume, velocity)
         
-        self.logger.info(f"Pulling {actual_volume} ml (from {self._position} to {new_position})")
+        self.logger.info(f"📥 开始吸液: {actual_volume:.2f}mL")
+        self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
+        self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
         
-        await self._simulate_operation(duration)
+        if self._fast_mode:
+            self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
+        
+        await self._simulate_operation(actual_duration)
         
         self._position = new_position
         self._current_volume = new_position
         
-        self.logger.info(f"Pulled {actual_volume} ml, current volume: {self._current_volume} ml")
+        self.logger.info(f"✅ 吸液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     async def push_plunger(self, volume: float, velocity: float = None):
         """
-        推出柱塞（排液）
+        推出柱塞（排液） 📤
         
         Args:
             volume (float): 要推出的体积 (ml)
@@ -207,35 +303,44 @@ class VirtualTransferPump:
         actual_volume = self._position - new_position
         
         if actual_volume <= 0:
-            self.logger.warning("Cannot push - already at minimum volume")
+            self.logger.warning("⚠️ 无法排液 - 已达到最小容量")
             return
         
-        duration = self._calculate_duration(actual_volume, velocity)
+        display_duration = self._calculate_display_duration(actual_volume, velocity)
+        actual_duration = self._calculate_duration(actual_volume, velocity)
         
-        self.logger.info(f"Pushing {actual_volume} ml (from {self._position} to {new_position})")
+        self.logger.info(f"📤 开始排液: {actual_volume:.2f}mL")
+        self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
+        self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
         
-        await self._simulate_operation(duration)
+        if self._fast_mode:
+            self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
+        
+        await self._simulate_operation(actual_duration)
         
         self._position = new_position
         self._current_volume = new_position
         
-        self.logger.info(f"Pushed {actual_volume} ml, current volume: {self._current_volume} ml")
+        self.logger.info(f"✅ 排液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     # 便捷操作方法
     async def aspirate(self, volume: float, velocity: float = None):
-        """吸液操作"""
+        """吸液操作 📥"""
         await self.pull_plunger(volume, velocity)
     
     async def dispense(self, volume: float, velocity: float = None):
-        """排液操作"""
+        """排液操作 📤"""
         await self.push_plunger(volume, velocity)
     
     async def transfer(self, volume: float, aspirate_velocity: float = None, dispense_velocity: float = None):
-        """转移操作（先吸后排）"""
+        """转移操作（先吸后排） 🔄"""
+        self.logger.info(f"🔄 开始转移操作: {volume:.2f}mL")
+        
         # 吸液
         await self.aspirate(volume, aspirate_velocity)
         
         # 短暂停顿
+        self.logger.debug("⏸️ 短暂停顿...")
         await asyncio.sleep(0.1)
         
         # 排液

unilabos/messages/__init__.py

@@ -10,18 +10,88 @@ class Point3D(BaseModel):
 # Start Protocols
 
 class PumpTransferProtocol(BaseModel):
+    # === 核心参数（保持必需） ===
     from_vessel: str
     to_vessel: str
-    volume: float
+    
+    # === 所有其他参数都改为可选，添加默认值 ===
+    volume: float = 0.0  # 🔧 改为-1，表示转移全部体积
     amount: str = ""
-    time: float = 0
+    time: float = 0.0
     viscous: bool = False
-    rinsing_solvent: str = "air"
-    rinsing_volume: float = 5000
-    rinsing_repeats: int = 2
+    rinsing_solvent: str = ""
+    rinsing_volume: float = 0.0
+    rinsing_repeats: int = 0
     solid: bool = False
-    flowrate: float = 500
-    transfer_flowrate: float = 2500
+    flowrate: float = 2.5
+    transfer_flowrate: float = 0.5
+    
+    # === 新版XDL兼容参数（可选） ===
+    rate_spec: str = ""
+    event: str = ""
+    through: str = ""
+    
+    def model_post_init(self, __context):
+        """后处理：智能参数处理和兼容性调整"""
+            
+        # 如果指定了 amount 但volume是默认值，尝试解析 amount
+        if self.amount and self.volume == 0.0:
+            parsed_volume = self._parse_amount_to_volume(self.amount)
+            if parsed_volume > 0:
+                self.volume = parsed_volume
+        
+        # 如果指定了 time 但没有明确设置流速，根据时间计算流速
+        if self.time > 0 and self.volume > 0:
+            if self.flowrate == 2.5 and self.transfer_flowrate == 0.5:
+                calculated_flowrate = self.volume / self.time
+                self.flowrate = min(calculated_flowrate, 10.0)
+                self.transfer_flowrate = min(calculated_flowrate, 5.0)
+        
+        # 🔧 核心修复：如果flowrate为0（ROS2传入），使用默认值
+        if self.flowrate <= 0:
+            self.flowrate = 2.5
+        if self.transfer_flowrate <= 0:
+            self.transfer_flowrate = 0.5
+            
+        # 根据 rate_spec 调整流速
+        if self.rate_spec == "dropwise":
+            self.flowrate = min(self.flowrate, 0.1)
+            self.transfer_flowrate = min(self.transfer_flowrate, 0.1)
+        elif self.rate_spec == "slowly":
+            self.flowrate = min(self.flowrate, 0.5)
+            self.transfer_flowrate = min(self.transfer_flowrate, 0.3)
+        elif self.rate_spec == "quickly":
+            self.flowrate = max(self.flowrate, 5.0)
+            self.transfer_flowrate = max(self.transfer_flowrate, 2.0)
+    
+    def _parse_amount_to_volume(self, amount: str) -> float:
+        """解析 amount 字符串为体积"""
+        if not amount:
+            return 0.0
+        
+        amount = amount.lower().strip()
+        
+        # 处理特殊关键词
+        if amount == "all":
+            return 0.0  # 🔧 "all"也表示转移全部
+        
+        # 提取数字
+        import re
+        numbers = re.findall(r'[\d.]+', amount)
+        if numbers:
+            volume = float(numbers[0])
+            
+            # 单位转换
+            if 'ml' in amount or 'milliliter' in amount:
+                return volume
+            elif 'l' in amount and 'ml' not in amount:
+                return volume * 1000
+            elif 'μl' in amount or 'microliter' in amount:
+                return volume / 1000
+            else:
+                return volume
+        
+        return 0.0
 
 
 class CleanProtocol(BaseModel):
@@ -49,17 +119,96 @@ class SeparateProtocol(BaseModel):
 
 
 class EvaporateProtocol(BaseModel):
-    vessel: str
-    pressure: float
-    temp: float
-    time: float
-    stir_speed: float
+    # === 核心参数（必需） ===
+    vessel: str = Field(..., description="蒸发容器名称")
+    
+    # === 所有其他参数都改为可选，添加默认值 ===
+    pressure: float = Field(0.1, description="真空度 (bar)，默认0.1 bar")
+    temp: float = Field(60.0, description="加热温度 (°C)，默认60°C")
+    time: float = Field(180.0, description="蒸发时间 (秒)，默认1800s (30分钟)")
+    stir_speed: float = Field(100.0, description="旋转速度 (RPM)，默认100 RPM")
+    
+    # === 新版XDL兼容参数（可选） ===
+    solvent: str = Field("", description="溶剂名称（用于识别蒸发的溶剂类型）")
+    
+    def model_post_init(self, __context):
+        """后处理：智能参数处理和兼容性调整"""
+        
+        # 参数范围验证和修正
+        if self.pressure <= 0 or self.pressure > 1.0:
+            logger.warning(f"真空度 {self.pressure} bar 超出范围，修正为 0.1 bar")
+            self.pressure = 0.1
+        
+        if self.temp < 10.0 or self.temp > 200.0:
+            logger.warning(f"温度 {self.temp}°C 超出范围，修正为 60°C")
+            self.temp = 60.0
+        
+        if self.time <= 0:
+            logger.warning(f"时间 {self.time}s 无效，修正为 1800s")
+            self.time = 1800.0
+        
+        if self.stir_speed < 10.0 or self.stir_speed > 300.0:
+            logger.warning(f"旋转速度 {self.stir_speed} RPM 超出范围，修正为 100 RPM")
+            self.stir_speed = 100.0
+        
+        # 根据溶剂类型调整参数
+        if self.solvent:
+            self._adjust_parameters_by_solvent()
+    
+    def _adjust_parameters_by_solvent(self):
+        """根据溶剂类型调整蒸发参数"""
+        solvent_lower = self.solvent.lower()
+        
+        # 水系溶剂：较高温度，较低真空度
+        if any(s in solvent_lower for s in ['water', 'aqueous', 'h2o']):
+            if self.temp == 60.0:  # 如果是默认值，则调整
+                self.temp = 80.0
+            if self.pressure == 0.1:
+                self.pressure = 0.2
+        
+        # 有机溶剂：根据沸点调整
+        elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+            if self.temp == 60.0:
+                self.temp = 50.0
+            if self.pressure == 0.1:
+                self.pressure = 0.05
+        
+        # 高沸点溶剂：更高温度
+        elif any(s in solvent_lower for s in ['dmso', 'dmi', 'toluene']):
+            if self.temp == 60.0:
+                self.temp = 100.0
+            if self.pressure == 0.1:
+                self.pressure = 0.01
 
 
 class EvacuateAndRefillProtocol(BaseModel):
-    vessel: str
-    gas: str
-    repeats: int
+    # === 必需参数 ===
+    vessel: str = Field(..., description="目标容器名称")
+    gas: str = Field(..., description="气体名称")
+    
+    # 🔧 删除 repeats 参数，直接在代码中硬编码为 3 次
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证和兼容性调整"""
+        
+        # 验证气体名称
+        if not self.gas.strip():
+            logger.warning("气体名称为空，使用默认值 'nitrogen'")
+            self.gas = "nitrogen"
+        
+        # 标准化气体名称
+        gas_aliases = {
+            'n2': 'nitrogen',
+            'ar': 'argon', 
+            'air': 'air',
+            'o2': 'oxygen',
+            'co2': 'carbon_dioxide',
+            'h2': 'hydrogen'
+        }
+        
+        gas_lower = self.gas.lower().strip()
+        if gas_lower in gas_aliases:
+            self.gas = gas_aliases[gas_lower]
 
 
 class AGVTransferProtocol(BaseModel):
@@ -88,42 +237,282 @@ class CentrifugeProtocol(BaseModel):
     temp: float
 
 class FilterProtocol(BaseModel):
-    vessel: str
-    filtrate_vessel: str
-    stir: bool
-    stir_speed: float
-    temp: float
-    continue_heatchill: bool
-    volume: float
+    # === 必需参数 ===
+    vessel: str = Field(..., description="过滤容器名称")
+    
+    # === 可选参数 ===
+    filtrate_vessel: str = Field("", description="滤液容器名称（可选，自动查找）")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证"""
+        # 验证容器名称
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
 
 class HeatChillProtocol(BaseModel):
-    vessel: str
-    temp: float
-    time: float
-    stir: bool
-    stir_speed: float
-    purpose: str
+    # === 必需参数 ===
+    vessel: str = Field(..., description="加热容器名称")
+    
+    # === 可选参数 - 温度相关 ===
+    temp: float = Field(25.0, description="目标温度 (°C)")
+    temp_spec: str = Field("", description="温度规格（如 'room temperature', 'reflux'）")
+    
+    # === 可选参数 - 时间相关 ===
+    time: float = Field(300.0, description="加热时间 (秒)")
+    time_spec: str = Field("", description="时间规格（如 'overnight', '2 h'）")
+    
+    # === 可选参数 - 其他XDL参数 ===
+    pressure: str = Field("", description="压力规格（如 '1 mbar'），不做特殊处理")
+    reflux_solvent: str = Field("", description="回流溶剂名称，不做特殊处理")
+    
+    # === 可选参数 - 搅拌相关 ===
+    stir: bool = Field(False, description="是否搅拌")
+    stir_speed: float = Field(300.0, description="搅拌速度 (RPM)")
+    purpose: str = Field("", description="操作目的")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证和解析"""
+        
+        # 验证必需参数
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
+        
+        # 温度解析：优先使用 temp_spec，然后是 temp
+        if self.temp_spec:
+            self.temp = self._parse_temp_spec(self.temp_spec)
+        
+        # 时间解析：优先使用 time_spec，然后是 time
+        if self.time_spec:
+            self.time = self._parse_time_spec(self.time_spec)
+        
+        # 参数范围验证
+        if self.temp < -50.0 or self.temp > 300.0:
+            logger.warning(f"温度 {self.temp}°C 超出范围，修正为 25°C")
+            self.temp = 25.0
+        
+        if self.time < 0:
+            logger.warning(f"时间 {self.time}s 无效，修正为 300s")
+            self.time = 300.0
+        
+        if self.stir_speed < 0 or self.stir_speed > 1500.0:
+            logger.warning(f"搅拌速度 {self.stir_speed} RPM 超出范围，修正为 300 RPM")
+            self.stir_speed = 300.0
+    
+    def _parse_temp_spec(self, temp_spec: str) -> float:
+        """解析温度规格为具体温度"""
+        
+        temp_spec = temp_spec.strip().lower()
+        
+        # 特殊温度规格
+        special_temps = {
+            "room temperature": 25.0,      # 室温
+            "reflux": 78.0,                 # 默认回流温度（乙醇沸点）
+            "ice bath": 0.0,                # 冰浴
+            "boiling": 100.0,               # 沸腾
+            "hot": 60.0,                    # 热
+            "warm": 40.0,                   # 温热
+            "cold": 10.0,                   # 冷
+        }
+        
+        if temp_spec in special_temps:
+            return special_temps[temp_spec]
+        
+        # 解析带单位的温度（如 "256 °C"）
+        import re
+        temp_pattern = r'(\d+(?:\.\d+)?)\s*°?[cf]?'
+        match = re.search(temp_pattern, temp_spec)
+        
+        if match:
+            return float(match.group(1))
+        
+        return 25.0  # 默认室温
+    
+    def _parse_time_spec(self, time_spec: str) -> float:
+        """解析时间规格为秒数"""
+        
+        time_spec = time_spec.strip().lower()
+        
+        # 特殊时间规格
+        special_times = {
+            "overnight": 43200.0,           # 12小时
+            "several hours": 10800.0,       # 3小时
+            "few hours": 7200.0,            # 2小时
+            "long time": 3600.0,            # 1小时
+            "short time": 300.0,            # 5分钟
+        }
+        
+        if time_spec in special_times:
+            return special_times[time_spec]
+        
+        # 解析带单位的时间（如 "2 h"）
+        import re
+        time_pattern = r'(\d+(?:\.\d+)?)\s*([a-zA-Z]+)'
+        match = re.search(time_pattern, time_spec)
+        
+        if match:
+            value = float(match.group(1))
+            unit = match.group(2).lower()
+            
+            unit_multipliers = {
+                's': 1.0,
+                'sec': 1.0,
+                'second': 1.0,
+                'seconds': 1.0,
+                'min': 60.0,
+                'minute': 60.0,
+                'minutes': 60.0,
+                'h': 3600.0,
+                'hr': 3600.0,
+                'hour': 3600.0,
+                'hours': 3600.0,
+            }
+            
+            multiplier = unit_multipliers.get(unit, 3600.0)  # 默认按小时计算
+            return value * multiplier
+        
+        return 300.0  # 默认5分钟
+
 
 class HeatChillStartProtocol(BaseModel):
-    vessel: str
-    temp: float
-    purpose: str
+    # === 必需参数 ===
+    vessel: str = Field(..., description="加热容器名称")
+
+    # === 可选参数 - 温度相关 ===
+    temp: float = Field(25.0, description="目标温度 (°C)")
+    temp_spec: str = Field("", description="温度规格（如 'room temperature', 'reflux'）")
+
+    # === 可选参数 - 其他XDL参数 ===
+    pressure: str = Field("", description="压力规格（如 '1 mbar'），不做特殊处理")
+    reflux_solvent: str = Field("", description="回流溶剂名称，不做特殊处理")
+
+    # === 可选参数 - 搅拌相关 ===
+    stir: bool = Field(False, description="是否搅拌")
+    stir_speed: float = Field(300.0, description="搅拌速度 (RPM)")
+    purpose: str = Field("", description="操作目的")
+
 
 class HeatChillStopProtocol(BaseModel):
-    vessel: str
+    # === 必需参数 ===
+    vessel: str = Field(..., description="加热容器名称")
+
 
 class StirProtocol(BaseModel):
-    stir_time: float
-    stir_speed: float
-    settling_time: float
+    # === 必需参数 ===
+    vessel: str = Field(..., description="搅拌容器名称")
+    
+    # === 可选参数 ===
+    time: str = Field("5 min", description="搅拌时间（如 '0.5 h', '30 min'）")
+    event: str = Field("", description="事件标识（如 'A', 'B'）")
+    time_spec: str = Field("", description="时间规格（如 'several minutes', 'overnight'）")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证和时间解析"""
+        
+        # 验证必需参数
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
+        
+        # 优先使用 time_spec，然后是 time
+        if self.time_spec:
+            self.time = self.time_spec
+        
+        # 时间解析和验证
+        if self.time:
+            try:
+                # 解析时间字符串为秒数
+                parsed_time = self._parse_time_string(self.time)
+                if parsed_time <= 0:
+                    logger.warning(f"时间 '{self.time}' 解析结果无效，使用默认值 300s")
+                    self.time = "5 min"
+            except Exception as e:
+                logger.warning(f"时间 '{self.time}' 解析失败: {e}，使用默认值 300s")
+                self.time = "5 min"
+    
+    def _parse_time_string(self, time_str: str) -> float:
+        """解析时间字符串为秒数"""
+        import re
+        
+        time_str = time_str.strip().lower()
+        
+        # 特殊时间规格
+        special_times = {
+            "several minutes": 300.0,    # 5分钟
+            "few minutes": 180.0,        # 3分钟
+            "overnight": 43200.0,        # 12小时
+            "room temperature": 300.0,   # 默认5分钟
+        }
+        
+        if time_str in special_times:
+            return special_times[time_str]
+        
+        # 正则表达式匹配数字和单位
+        pattern = r'(\d+\.?\d*)\s*([a-zA-Z]+)'
+        match = re.match(pattern, time_str)
+        
+        if not match:
+            return 300.0  # 默认5分钟
+        
+        value = float(match.group(1))
+        unit = match.group(2).lower()
+        
+        # 时间单位转换
+        unit_multipliers = {
+            's': 1.0,
+            'sec': 1.0,
+            'second': 1.0,
+            'seconds': 1.0,
+            'min': 60.0,
+            'minute': 60.0,
+            'minutes': 60.0,
+            'h': 3600.0,
+            'hr': 3600.0,
+            'hour': 3600.0,
+            'hours': 3600.0,
+            'd': 86400.0,
+            'day': 86400.0,
+            'days': 86400.0,
+        }
+        
+        multiplier = unit_multipliers.get(unit, 60.0)  # 默认按分钟计算
+        return value * multiplier
+    
+    def get_time_in_seconds(self) -> float:
+        """获取时间（秒）"""
+        return self._parse_time_string(self.time)
 
 class StartStirProtocol(BaseModel):
-    vessel: str
-    stir_speed: float
-    purpose: str
+    # === 必需参数 ===
+    vessel: str = Field(..., description="搅拌容器名称")
+    
+    # === 可选参数，添加默认值 ===
+    stir_speed: float = Field(200.0, description="搅拌速度 (RPM)，默认200 RPM")
+    purpose: str = Field("", description="搅拌目的（可选）")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证和修正"""
+        
+        # 验证必需参数
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
+        
+        # 修正参数范围
+        if self.stir_speed < 10.0:
+            logger.warning(f"搅拌速度 {self.stir_speed} RPM 过低，修正为 100 RPM")
+            self.stir_speed = 100.0
+        elif self.stir_speed > 1500.0:
+            logger.warning(f"搅拌速度 {self.stir_speed} RPM 过高，修正为 1000 RPM")
+            self.stir_speed = 1000.0
 
 class StopStirProtocol(BaseModel):
-    vessel: str
+    # === 必需参数 ===
+    vessel: str = Field(..., description="搅拌容器名称")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证"""
+        
+        # 验证必需参数
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
 
 class TransferProtocol(BaseModel):
     from_vessel: str
@@ -168,16 +557,52 @@ class RunColumnProtocol(BaseModel):
     column: str
 
 class WashSolidProtocol(BaseModel):
-    vessel: str
-    solvent: str
-    volume: float
-    filtrate_vessel: str = ""
-    temp: float = 25.0
-    stir: bool = False
-    stir_speed: float = 0.0
-    time: float = 0.0
-    repeats: int = 1
-
+    # === 必需参数 ===
+    vessel: str = Field(..., description="装有固体的容器名称")
+    solvent: str = Field(..., description="清洗溶剂名称")
+    volume: float = Field(..., description="清洗溶剂体积 (mL)")
+    
+    # === 可选参数，添加默认值 ===
+    filtrate_vessel: str = Field("", description="滤液收集容器（可选，自动查找）")
+    temp: float = Field(25.0, description="清洗温度 (°C)，默认25°C")
+    stir: bool = Field(False, description="是否搅拌，默认False")
+    stir_speed: float = Field(0.0, description="搅拌速度 (RPM)，默认0")
+    time: float = Field(0.0, description="清洗时间 (秒)，默认0")
+    repeats: int = Field(1, description="重复次数，默认1")
+    
+    def model_post_init(self, __context):
+        """后处理：参数验证和修正"""
+        
+        # 验证必需参数
+        if not self.vessel.strip():
+            raise ValueError("vessel 参数不能为空")
+        
+        if not self.solvent.strip():
+            raise ValueError("solvent 参数不能为空")
+        
+        if self.volume <= 0:
+            raise ValueError("volume 必须大于0")
+        
+        # 修正参数范围
+        if self.temp < 0 or self.temp > 200:
+            logger.warning(f"温度 {self.temp}°C 超出范围，修正为 25°C")
+            self.temp = 25.0
+        
+        if self.stir_speed < 0 or self.stir_speed > 500:
+            logger.warning(f"搅拌速度 {self.stir_speed} RPM 超出范围，修正为 0")
+            self.stir_speed = 0.0
+        
+        if self.time < 0:
+            logger.warning(f"时间 {self.time}s 无效，修正为 0")
+            self.time = 0.0
+        
+        if self.repeats < 1:
+            logger.warning(f"重复次数 {self.repeats} 无效，修正为 1")
+            self.repeats = 1
+        elif self.repeats > 10:
+            logger.warning(f"重复次数 {self.repeats} 过多，修正为 10")
+            self.repeats = 10
+            
 class AdjustPHProtocol(BaseModel):
     vessel: str = Field(..., description="目标容器")
     ph_value: float = Field(..., description="目标pH值")  # 改为 ph_value
@@ -207,7 +632,8 @@ __all__ = [
     "Point3D", "PumpTransferProtocol", "CleanProtocol", "SeparateProtocol", 
     "EvaporateProtocol", "EvacuateAndRefillProtocol", "AGVTransferProtocol", 
     "CentrifugeProtocol", "AddProtocol", "FilterProtocol", 
-    "HeatChillProtocol", "HeatChillStartProtocol", "HeatChillStopProtocol", 
+    "HeatChillProtocol",
+    "HeatChillStartProtocol", "HeatChillStopProtocol",
     "StirProtocol", "StartStirProtocol", "StopStirProtocol", 
     "TransferProtocol", "CleanVesselProtocol", "DissolveProtocol", 
     "FilterThroughProtocol", "RunColumnProtocol", "WashSolidProtocol",

unilabos/registry/device_comms/serial.yaml

@@ -100,3 +100,4 @@ serial:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/camera.yaml

@@ -8,7 +8,7 @@ camera:
         handles: []
         result: {}
         schema:
-          description: destroy_node的参数schema
+          description: 用于安全地关闭摄像头设备，释放摄像头资源，停止视频采集和发布服务。调用此函数将清理OpenCV摄像头连接并销毁ROS2节点。
           properties:
             feedback: {}
             goal:
@@ -28,7 +28,7 @@ camera:
         handles: []
         result: {}
         schema:
-          description: timer_callback的参数schema
+          description: 定时器回调函数的参数schema。此函数负责定期采集摄像头视频帧，将OpenCV格式的图像转换为ROS Image消息格式，并发布到指定的视频话题。默认以10Hz频率执行，确保视频流的连续性和实时性。
           properties:
             feedback: {}
             goal:
@@ -44,7 +44,7 @@ camera:
     module: unilabos.ros.nodes.presets.camera:VideoPublisher
     status_types: {}
     type: ros2
-  description: ''
+  description: VideoPublisher摄像头设备节点，用于实时视频采集和流媒体发布。该设备通过OpenCV连接本地摄像头（如USB摄像头、内置摄像头等），定时采集视频帧并将其转换为ROS2的sensor_msgs/Image消息格式发布到视频话题。主要用于实验室自动化系统中的视觉监控、图像分析、实时观察等应用场景。支持可配置的摄像头索引、发布频率等参数。
   handles: []
   icon: ''
   init_param_schema:
@@ -67,3 +67,4 @@ camera:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/characterization_optic.yaml

@@ -8,7 +8,7 @@ hplc.agilent:
         handles: []
         result: {}
         schema:
-          description: check_status的参数schema
+          description: 检查安捷伦HPLC设备状态的函数。用于监控设备的运行状态、连接状态、错误信息等关键指标。该函数定期查询设备状态，确保系统稳定运行，及时发现和报告设备异常。适用于自动化流程中的设备监控、故障诊断、系统维护等场景。
           properties:
             feedback: {}
             goal:
@@ -29,7 +29,7 @@ hplc.agilent:
         handles: []
         result: {}
         schema:
-          description: extract_data_from_txt的参数schema
+          description: 从文本文件中提取分析数据的函数。用于解析安捷伦HPLC生成的结果文件，提取峰面积、保留时间、浓度等关键分析数据。支持多种文件格式的自动识别和数据结构化处理，为后续数据分析和报告生成提供标准化的数据格式。适用于批量数据处理、结果验证、质量控制等分析工作流程。
           properties:
             feedback: {}
             goal:
@@ -55,7 +55,7 @@ hplc.agilent:
         handles: []
         result: {}
         schema:
-          description: start_sequence的参数schema
+          description: 启动安捷伦HPLC分析序列的函数。用于执行预定义的分析方法序列，包括样品进样、色谱分离、检测等完整的分析流程。支持参数配置、资源分配、工作流程管理等功能，实现全自动的样品分析。适用于批量样品处理、标准化分析、质量检测等需要连续自动分析的应用场景。
           properties:
             feedback: {}
             goal:
@@ -83,7 +83,7 @@ hplc.agilent:
         handles: []
         result: {}
         schema:
-          description: try_close_sub_device的参数schema
+          description: 尝试关闭HPLC子设备的函数。用于安全地关闭泵、检测器、进样器等各个子模块，确保设备正常断开连接并保护硬件安全。该函数提供错误处理和状态确认机制，避免强制关闭可能造成的设备损坏。适用于设备维护、系统重启、紧急停机等需要安全关闭设备的场景。
           properties:
             feedback: {}
             goal:
@@ -106,7 +106,7 @@ hplc.agilent:
         handles: []
         result: {}
         schema:
-          description: try_open_sub_device的参数schema
+          description: 尝试打开HPLC子设备的函数。用于初始化和连接泵、检测器、进样器等各个子模块，建立设备通信并进行自检。该函数提供连接验证和错误恢复机制，确保子设备正常启动并准备就绪。适用于设备初始化、系统启动、设备重连等需要建立设备连接的场景。
           properties:
             feedback: {}
             goal:
@@ -131,10 +131,9 @@ hplc.agilent:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -143,7 +142,6 @@ hplc.agilent:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -152,7 +150,6 @@ hplc.agilent:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -179,7 +176,7 @@ hplc.agilent:
       status_text: str
       success: bool
     type: python
-  description: HPLC device
+  description: 安捷伦高效液相色谱（HPLC）分析设备，用于复杂化合物的分离、检测和定量分析。该设备通过UI自动化技术控制安捷伦ChemStation软件，实现全自动的样品分析流程。具备序列启动、设备状态监控、数据文件提取、结果处理等功能。支持多样品批量处理和实时状态反馈，适用于药物分析、环境检测、食品安全、化学研究等需要高精度色谱分析的实验室应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -218,6 +215,7 @@ hplc.agilent:
       - finish_status
       - data_file
       type: object
+  version: 0.0.1
 raman_home_made:
   class:
     action_value_mappings:
@@ -229,7 +227,7 @@ raman_home_made:
         handles: []
         result: {}
         schema:
-          description: ccd_time的参数schema
+          description: 设置CCD检测器积分时间的函数。用于配置拉曼光谱仪的信号采集时间，控制光谱数据的质量和信噪比。较长的积分时间可获得更高的信号强度和更好的光谱质量，但会增加测量时间。该函数允许根据样品特性和测量要求动态调整检测参数，优化测量效果。
           properties:
             feedback: {}
             goal:
@@ -253,7 +251,7 @@ raman_home_made:
         handles: []
         result: {}
         schema:
-          description: laser_on_power的参数schema
+          description: 设置激光器输出功率的函数。用于控制拉曼光谱仪激光器的功率输出，调节激光强度以适应不同样品的测量需求。适当的激光功率能够获得良好的拉曼信号同时避免样品损伤。该函数支持精确的功率控制，确保测量结果的稳定性和重现性。
           properties:
             feedback: {}
             goal:
@@ -269,30 +267,6 @@ raman_home_made:
           title: laser_on_power参数
           type: object
         type: UniLabJsonCommand
-      auto-raman_cmd:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: raman_cmd的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: raman_cmd参数
-          type: object
-        type: UniLabJsonCommand
       auto-raman_without_background:
         feedback: {}
         goal: {}
@@ -302,7 +276,7 @@ raman_home_made:
         handles: []
         result: {}
         schema:
-          description: raman_without_background的参数schema
+          description: 执行无背景扣除的拉曼光谱测量函数。用于直接采集样品的拉曼光谱信号，不进行背景校正处理。该函数配置积分时间和激光功率参数，获取原始光谱数据用于后续的数据处理分析。适用于对光谱数据质量要求较高或需要自定义背景处理流程的测量场景。
           properties:
             feedback: {}
             goal:
@@ -332,7 +306,7 @@ raman_home_made:
         handles: []
         result: {}
         schema:
-          description: raman_without_background_average的参数schema
+          description: 执行多次平均的无背景拉曼光谱测量函数。通过多次测量取平均值来提高光谱数据的信噪比和测量精度，减少随机噪声影响。该函数支持自定义平均次数、积分时间、激光功率等参数，并可为样品指定名称便于数据管理。适用于对测量精度要求较高的定量分析和研究应用。
           properties:
             feedback: {}
             goal:
@@ -367,10 +341,9 @@ raman_home_made:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -379,7 +352,6 @@ raman_home_made:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -388,7 +360,6 @@ raman_home_made:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -407,7 +378,7 @@ raman_home_made:
     module: unilabos.devices.raman_uv.home_made_raman:RamanObj
     status_types: {}
     type: python
-  description: Raman spectroscopy device
+  description: 拉曼光谱分析设备，用于物质的分子结构和化学成分表征。该设备集成激光器和CCD检测器，通过串口通信控制激光功率和光谱采集。具备背景扣除、多次平均、自动数据处理等功能，支持高精度的拉曼光谱测量。适用于材料表征、化学分析、质量控制、研究开发等需要分子指纹识别和结构分析的实验应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -431,3 +402,4 @@ raman_home_made:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/hotel.yaml

@@ -5,7 +5,7 @@ hotel.thermo_orbitor_rs2_hotel:
     status_types:
       rotation: String
     type: python
-  description: Thermo Orbitor RS2 Hotel
+  description: Thermo Orbitor RS2 Hotel容器设备，用于实验室样品的存储和管理。该设备通过HotelContainer类实现容器的旋转控制和状态监控，主要用于存储实验样品、试剂瓶或其他实验器具，支持旋转功能以便于样品的自动化存取。适用于需要有序存储和快速访问大量样品的实验室自动化场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -29,3 +29,4 @@ hotel.thermo_orbitor_rs2_hotel:
   model:
     mesh: thermo_orbitor_rs2_hotel
     type: device
+  version: 0.0.1

unilabos/registry/devices/laiyu_add_solid.yaml

@@ -15,16 +15,14 @@ laiyu_add_solid:
         result:
           actual_mass_mg: actual_mass_mg
         schema:
-          description: ROS Action SolidDispenseAddPowderTube 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: SolidDispenseAddPowderTube_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 compound_mass:
                   type: number
@@ -41,7 +39,6 @@ laiyu_add_solid:
               title: SolidDispenseAddPowderTube_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 actual_mass_mg:
                   type: number
@@ -60,38 +57,6 @@ laiyu_add_solid:
           title: SolidDispenseAddPowderTube
           type: object
         type: SolidDispenseAddPowderTube
-      auto-add_powder_tube:
-        feedback: {}
-        goal: {}
-        goal_default:
-          compound_mass: null
-          powder_tube_number: null
-          target_tube_position: null
-        handles: []
-        result: {}
-        schema:
-          description: add_powder_tube的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                compound_mass:
-                  type: string
-                powder_tube_number:
-                  type: string
-                target_tube_position:
-                  type: string
-              required:
-              - powder_tube_number
-              - target_tube_position
-              - compound_mass
-              type: object
-            result: {}
-          required:
-          - goal
-          title: add_powder_tube参数
-          type: object
-        type: UniLabJsonCommand
       auto-calculate_crc:
         feedback: {}
         goal: {}
@@ -100,7 +65,7 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: calculate_crc的参数schema
+          description: Modbus CRC-16校验码计算函数。计算Modbus RTU通信协议所需的CRC-16校验码，确保数据传输的完整性和可靠性。该函数实现标准的CRC-16算法，用于构造完整的Modbus指令帧。
           properties:
             feedback: {}
             goal:
@@ -116,154 +81,6 @@ laiyu_add_solid:
           title: calculate_crc参数
           type: object
         type: UniLabJsonCommand
-      auto-discharge:
-        feedback: {}
-        goal: {}
-        goal_default:
-          float_in: null
-        handles: []
-        result: {}
-        schema:
-          description: discharge的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                float_in:
-                  type: number
-              required:
-              - float_in
-              type: object
-            result: {}
-          required:
-          - goal
-          title: discharge参数
-          type: object
-        type: UniLabJsonCommand
-      auto-move_to_plate:
-        feedback: {}
-        goal: {}
-        goal_default:
-          string: null
-        handles: []
-        result: {}
-        schema:
-          description: move_to_plate的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                string:
-                  type: string
-              required:
-              - string
-              type: object
-            result: {}
-          required:
-          - goal
-          title: move_to_plate参数
-          type: object
-        type: UniLabJsonCommand
-      auto-move_to_xyz:
-        feedback: {}
-        goal: {}
-        goal_default:
-          x: null
-          y: null
-          z: null
-        handles: []
-        result: {}
-        schema:
-          description: move_to_xyz的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                x:
-                  type: number
-                y:
-                  type: number
-                z:
-                  type: number
-              required:
-              - x
-              - y
-              - z
-              type: object
-            result: {}
-          required:
-          - goal
-          title: move_to_xyz参数
-          type: object
-        type: UniLabJsonCommand
-      auto-pick_powder_tube:
-        feedback: {}
-        goal: {}
-        goal_default:
-          int_input: null
-        handles: []
-        result: {}
-        schema:
-          description: pick_powder_tube的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                int_input:
-                  type: integer
-              required:
-              - int_input
-              type: object
-            result: {}
-          required:
-          - goal
-          title: pick_powder_tube参数
-          type: object
-        type: UniLabJsonCommand
-      auto-put_powder_tube:
-        feedback: {}
-        goal: {}
-        goal_default:
-          int_input: null
-        handles: []
-        result: {}
-        schema:
-          description: put_powder_tube的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                int_input:
-                  type: integer
-              required:
-              - int_input
-              type: object
-            result: {}
-          required:
-          - goal
-          title: put_powder_tube参数
-          type: object
-        type: UniLabJsonCommand
-      auto-reset:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: reset的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: reset参数
-          type: object
-        type: UniLabJsonCommand
       auto-send_command:
         feedback: {}
         goal: {}
@@ -272,7 +89,7 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: send_command的参数schema
+          description: Modbus指令发送函数。构造完整的Modbus RTU指令帧（包含CRC校验），发送给分装设备并等待响应。该函数处理底层通信协议，确保指令的正确传输和响应接收，支持最长3分钟的响应等待时间。
           properties:
             feedback: {}
             goal:
@@ -297,16 +114,14 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action FloatSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: FloatSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 float_in:
                   type: number
@@ -315,7 +130,6 @@ laiyu_add_solid:
               title: FloatSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -340,16 +154,14 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action StrSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 string:
                   type: string
@@ -358,7 +170,6 @@ laiyu_add_solid:
               title: StrSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -387,16 +198,14 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action Point3DSeparateInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: Point3DSeparateInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 x:
                   type: number
@@ -411,7 +220,6 @@ laiyu_add_solid:
               title: Point3DSeparateInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -436,16 +244,14 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action IntSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: IntSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 int_input:
                   maximum: 2147483647
@@ -456,7 +262,6 @@ laiyu_add_solid:
               title: IntSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -481,16 +286,14 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action IntSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: IntSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 int_input:
                   maximum: 2147483647
@@ -501,7 +304,6 @@ laiyu_add_solid:
               title: IntSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -524,22 +326,19 @@ laiyu_add_solid:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -556,7 +355,7 @@ laiyu_add_solid:
     status_types:
       status: str
     type: python
-  description: Laiyu Add Solid
+  description: 来渝固体粉末自动分装设备，用于实验室化学试剂的精确称量和分装。该设备通过Modbus RTU协议与控制系统通信，集成了精密天平、三轴运动平台、粉筒管理系统等组件。支持多种粉末试剂的自动拿取、精确称量、定点分装和归位操作。具备高精度称量、位置控制和批量处理能力，适用于化学合成、药物研发、材料制备等需要精确固体试剂配制的实验室应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -580,3 +379,4 @@ laiyu_add_solid:
       required:
       - status
       type: object
+  version: 0.0.1

unilabos/registry/devices/moveit_config.yaml

@@ -117,30 +117,6 @@ moveit.arm_slider:
           title: moveit_task参数
           type: object
         type: UniLabJsonCommand
-      auto-pick_and_place:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: pick_and_place的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: pick_and_place参数
-          type: object
-        type: UniLabJsonCommand
       auto-post_init:
         feedback: {}
         goal: {}
@@ -193,54 +169,6 @@ moveit.arm_slider:
           title: resource_manager参数
           type: object
         type: UniLabJsonCommand
-      auto-set_position:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_position的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_position参数
-          type: object
-        type: UniLabJsonCommand
-      auto-set_status:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_status的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_status参数
-          type: object
-        type: UniLabJsonCommand
       auto-wait_for_resource_action:
         feedback: {}
         goal: {}
@@ -270,10 +198,9 @@ moveit.arm_slider:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -282,7 +209,6 @@ moveit.arm_slider:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -291,7 +217,6 @@ moveit.arm_slider:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -316,10 +241,9 @@ moveit.arm_slider:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -328,7 +252,6 @@ moveit.arm_slider:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -337,7 +260,6 @@ moveit.arm_slider:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -362,10 +284,9 @@ moveit.arm_slider:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -374,7 +295,6 @@ moveit.arm_slider:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -383,7 +303,6 @@ moveit.arm_slider:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -402,7 +321,7 @@ moveit.arm_slider:
     module: unilabos.devices.ros_dev.moveit_interface:MoveitInterface
     status_types: {}
     type: python
-  description: Arm with Slider
+  description: 机械臂与滑块运动系统，基于MoveIt2运动规划框架的多自由度机械臂控制设备。该系统集成机械臂和线性滑块，通过ROS2和MoveIt2实现精确的轨迹规划和协调运动控制。支持笛卡尔空间和关节空间的运动规划、碰撞检测、逆运动学求解等功能。适用于复杂的pick-and-place操作、精密装配、多工位协作等需要高精度多轴协调运动的实验室自动化应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -427,6 +346,7 @@ moveit.arm_slider:
   model:
     mesh: arm_slider
     type: device
+  version: 0.0.1
 moveit.toyo_xyz:
   class:
     action_value_mappings:
@@ -546,30 +466,6 @@ moveit.toyo_xyz:
           title: moveit_task参数
           type: object
         type: UniLabJsonCommand
-      auto-pick_and_place:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: pick_and_place的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: pick_and_place参数
-          type: object
-        type: UniLabJsonCommand
       auto-post_init:
         feedback: {}
         goal: {}
@@ -622,54 +518,6 @@ moveit.toyo_xyz:
           title: resource_manager参数
           type: object
         type: UniLabJsonCommand
-      auto-set_position:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_position的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_position参数
-          type: object
-        type: UniLabJsonCommand
-      auto-set_status:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_status的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_status参数
-          type: object
-        type: UniLabJsonCommand
       auto-wait_for_resource_action:
         feedback: {}
         goal: {}
@@ -699,10 +547,9 @@ moveit.toyo_xyz:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -711,7 +558,6 @@ moveit.toyo_xyz:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -720,7 +566,6 @@ moveit.toyo_xyz:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -745,10 +590,9 @@ moveit.toyo_xyz:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -757,7 +601,6 @@ moveit.toyo_xyz:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -766,7 +609,6 @@ moveit.toyo_xyz:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -791,10 +633,9 @@ moveit.toyo_xyz:
         handles: []
         result: {}
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -803,7 +644,6 @@ moveit.toyo_xyz:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -812,7 +652,6 @@ moveit.toyo_xyz:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -831,7 +670,7 @@ moveit.toyo_xyz:
     module: unilabos.devices.ros_dev.moveit_interface:MoveitInterface
     status_types: {}
     type: python
-  description: Toyo XYZ
+  description: 东洋XYZ三轴运动平台，基于MoveIt2运动规划框架的精密定位设备。该设备通过ROS2和MoveIt2实现三维空间的精确运动控制，支持复杂轨迹规划、多点定位、速度控制等功能。具备高精度定位、平稳运动、实时轨迹监控等特性。适用于精密加工、样品定位、检测扫描、自动化装配等需要高精度三维运动控制的实验室和工业应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -856,3 +695,4 @@ moveit.toyo_xyz:
   model:
     mesh: toyo_xyz
     type: device
+  version: 0.0.1

unilabos/registry/devices/organic_miscellaneous.yaml

@@ -93,30 +93,6 @@ rotavap.one:
           title: set_rotate_time参数
           type: object
         type: UniLabJsonCommand
-      auto-set_timer:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_timer的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_timer参数
-          type: object
-        type: UniLabJsonCommand
       set_timer:
         feedback: {}
         goal:
@@ -127,10 +103,9 @@ rotavap.one:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -139,7 +114,6 @@ rotavap.one:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -148,7 +122,6 @@ rotavap.one:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -167,7 +140,7 @@ rotavap.one:
     module: unilabos.devices.rotavap.rotavap_one:RotavapOne
     status_types: {}
     type: python
-  description: Rotavap device
+  description: 旋转蒸发仪设备，用于有机化学实验中的溶剂回收和浓缩操作。该设备通过串口通信控制，集成旋转和真空泵功能，支持定时控制和自动化操作。具备旋转速度调节、真空度控制、温度管理等功能，实现高效的溶剂蒸发和回收。适用于有机合成、天然产物提取、药物制备等需要溶剂去除和浓缩的实验室应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -185,6 +158,7 @@ rotavap.one:
       properties: {}
       required: []
       type: object
+  version: 0.0.1
 separator.homemade:
   class:
     action_value_mappings:
@@ -208,38 +182,6 @@ separator.homemade:
           title: read_sensor_loop参数
           type: object
         type: UniLabJsonCommand
-      auto-stir:
-        feedback: {}
-        goal: {}
-        goal_default:
-          settling_time: 10
-          stir_speed: 300
-          stir_time: 10
-        handles: []
-        result: {}
-        schema:
-          description: stir的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                settling_time:
-                  default: 10
-                  type: number
-                stir_speed:
-                  default: 300
-                  type: number
-                stir_time:
-                  default: 10
-                  type: number
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: stir参数
-          type: object
-        type: UniLabJsonCommand
       auto-valve_open:
         feedback: {}
         goal: {}
@@ -268,30 +210,6 @@ separator.homemade:
           title: valve_open参数
           type: object
         type: UniLabJsonCommand
-      auto-valve_open_cmd:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: valve_open_cmd的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: valve_open_cmd参数
-          type: object
-        type: UniLabJsonCommand
       auto-write:
         feedback: {}
         goal: {}
@@ -331,10 +249,9 @@ separator.homemade:
         result:
           success: success
         schema:
-          description: ROS Action Stir 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -343,7 +260,6 @@ separator.homemade:
               title: Stir_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 settling_time:
                   type: number
@@ -358,7 +274,6 @@ separator.homemade:
               title: Stir_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -382,13 +297,12 @@ separator.homemade:
         goal_default:
           command: ''
         handles: []
-        result":
+        result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -397,7 +311,6 @@ separator.homemade:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -406,7 +319,6 @@ separator.homemade:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -425,7 +337,7 @@ separator.homemade:
     module: unilabos.devices.separator.homemade_grbl_conductivity:SeparatorController
     status_types: {}
     type: python
-  description: Separator device with homemade grbl controller
+  description: 液-液分离器设备，基于自制Grbl控制器的自动化分离系统。该设备集成搅拌、沉降、阀门控制和电导率传感器，通过串口通信实现精确的分离操作控制。支持自动搅拌、分层沉降、基于传感器反馈的智能分液等功能。适用于有机化学中的萃取分离、相分离、液-液提取等需要精确分离控制的实验应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -449,3 +361,4 @@ separator.homemade:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/pump_and_valve.yaml

@@ -68,7 +68,7 @@ solenoid_valve:
         handles: []
         result: {}
         schema:
-          description: open的参数schema
+          description: ''
           properties:
             feedback: {}
             goal:
@@ -125,30 +125,6 @@ solenoid_valve:
           title: send_command参数
           type: object
         type: UniLabJsonCommand
-      auto-set_valve_position:
-        feedback: {}
-        goal: {}
-        goal_default:
-          position: null
-        handles: []
-        result: {}
-        schema:
-          description: set_valve_position的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                position:
-                  type: string
-              required:
-              - position
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_valve_position参数
-          type: object
-        type: UniLabJsonCommand
       set_valve_position:
         feedback: {}
         goal:
@@ -158,16 +134,14 @@ solenoid_valve:
         handles: []
         result: {}
         schema:
-          description: ROS Action StrSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 string:
                   type: string
@@ -176,7 +150,6 @@ solenoid_valve:
               title: StrSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -197,7 +170,7 @@ solenoid_valve:
       status: str
       valve_position: str
     type: python
-  description: Solenoid valve
+  description: 电磁阀控制设备，用于精确的流体路径控制和开关操作。该设备通过串口通信控制电磁阀的开关状态，支持远程操作和状态监测。具备快速响应、可靠密封、状态反馈等特性，广泛应用于流体输送、样品进样、路径切换等需要精确流体控制的实验室自动化应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -218,29 +191,10 @@ solenoid_valve:
       - status
       - valve_position
       type: object
+  version: 0.0.1
 solenoid_valve.mock:
   class:
     action_value_mappings:
-      auto-close:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: close的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: close参数
-          type: object
-        type: UniLabJsonCommand
       auto-is_closed:
         feedback: {}
         goal: {}
@@ -281,26 +235,6 @@ solenoid_valve.mock:
           title: is_open参数
           type: object
         type: UniLabJsonCommand
-      auto-open:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: open的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: open参数
-          type: object
-        type: UniLabJsonCommand
       auto-set_valve_position:
         feedback: {}
         goal: {}
@@ -332,22 +266,19 @@ solenoid_valve.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -367,22 +298,19 @@ solenoid_valve.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -400,7 +328,7 @@ solenoid_valve.mock:
       status: str
       valve_position: str
     type: python
-  description: Mock solenoid valve
+  description: 模拟电磁阀设备，用于系统测试和开发调试。该设备模拟真实电磁阀的开关操作和状态变化，提供与实际设备相同的控制接口和反馈机制。支持流体路径的虚拟控制，便于在没有实际硬件的情况下进行流体系统的集成测试和算法验证。适用于系统开发、流程调试和培训演示等场景。
   handles:
   - data_type: fluid
     handler_key: in
@@ -431,6 +359,7 @@ solenoid_valve.mock:
       - status
       - valve_position
       type: object
+  version: 0.0.1
 syringe_pump_with_valve.runze:
   class:
     action_value_mappings:
@@ -825,7 +754,7 @@ syringe_pump_with_valve.runze:
       velocity_grade: String
       velocity_init: String
     type: python
-  description: Runze Syringe pump with valve
+  description: 润泽精密注射泵设备，集成阀门控制的高精度流体输送系统。该设备通过串口通信控制，支持多种运行模式和精确的体积控制。具备可变速度控制、精密定位、阀门切换、实时状态监控等功能。适用于微量液体输送、精密进样、流速控制、化学反应进料等需要高精度流体操作的实验室自动化应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -875,3 +804,4 @@ syringe_pump_with_valve.runze:
       - position
       - plunger_position
       type: object
+  version: 0.0.1

unilabos/registry/devices/robot_agv.yaml

@@ -11,7 +11,7 @@ agv.SEER:
         handles: []
         result: {}
         schema:
-          description: send的参数schema
+          description: AGV底层通信命令发送函数。通过TCP socket连接向AGV发送底层控制命令，支持pose（位置）、status（状态）、nav（导航）等命令类型。用于获取AGV当前位置坐标、运行状态或发送导航指令。该函数封装了AGV的通信协议，将命令转换为十六进制数据包并处理响应解析。
           properties:
             feedback: {}
             goal:
@@ -33,30 +33,6 @@ agv.SEER:
           title: send参数
           type: object
         type: UniLabJsonCommand
-      auto-send_nav_task:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: send_nav_task的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: send_nav_task参数
-          type: object
-        type: UniLabJsonCommand
       send_nav_task:
         feedback: {}
         goal:
@@ -67,10 +43,9 @@ agv.SEER:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -79,7 +54,6 @@ agv.SEER:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -88,7 +62,6 @@ agv.SEER:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -109,7 +82,7 @@ agv.SEER:
       pose: list
       status: str
     type: python
-  description: SEER AGV
+  description: SEER AGV自动导引车设备，用于实验室内物料和设备的自主移动运输。该AGV通过TCP socket与导航系统通信，具备精确的定位和路径规划能力。支持实时位置监控、状态查询和导航任务执行，可在预设的实验室环境中自主移动至指定位置。适用于样品运输、设备转移、多工位协作等实验室自动化物流场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -130,3 +103,4 @@ agv.SEER:
       - pose
       - status
       type: object
+  version: 0.0.1

unilabos/registry/devices/robot_arm.yaml

@@ -8,7 +8,7 @@ robotic_arm.UR:
         handles: []
         result: {}
         schema:
-          description: arm_init的参数schema
+          description: 机械臂初始化函数。执行UR机械臂的完整初始化流程，包括上电、释放制动器、解除保护停止状态等。该函数确保机械臂从安全停止状态恢复到可操作状态，是机械臂使用前的必要步骤。初始化完成后机械臂将处于就绪状态，可以接收后续的运动指令。
           properties:
             feedback: {}
             goal:
@@ -29,7 +29,7 @@ robotic_arm.UR:
         handles: []
         result: {}
         schema:
-          description: load_pose_data的参数schema
+          description: 从JSON字符串加载位置数据函数。接收包含机械臂位置信息的JSON格式字符串，解析并存储位置数据供后续运动任务使用。位置数据通常包含多个预定义的工作位置坐标，用于实现精确的多点运动控制。适用于动态配置机械臂工作位置的场景。
           properties:
             feedback: {}
             goal:
@@ -53,7 +53,7 @@ robotic_arm.UR:
         handles: []
         result: {}
         schema:
-          description: load_pose_file的参数schema
+          description: 从文件加载位置数据函数。读取指定的JSON文件并加载其中的机械臂位置信息。该函数支持从外部配置文件中获取预设的工作位置，便于位置数据的管理和重用。适用于需要从固定配置文件中读取复杂位置序列的应用场景。
           properties:
             feedback: {}
             goal:
@@ -69,30 +69,6 @@ robotic_arm.UR:
           title: load_pose_file参数
           type: object
         type: UniLabJsonCommand
-      auto-move_pos_task:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: move_pos_task的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: move_pos_task参数
-          type: object
-        type: UniLabJsonCommand
       auto-reload_pose:
         feedback: {}
         goal: {}
@@ -100,7 +76,7 @@ robotic_arm.UR:
         handles: []
         result: {}
         schema:
-          description: reload_pose的参数schema
+          description: 重新加载位置数据函数。重新读取并解析之前设置的位置文件，更新内存中的位置数据。该函数用于在位置文件被修改后刷新机械臂的位置配置，无需重新初始化整个系统。适用于动态更新机械臂工作位置的场景。
           properties:
             feedback: {}
             goal:
@@ -123,10 +99,9 @@ robotic_arm.UR:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -135,7 +110,6 @@ robotic_arm.UR:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -144,7 +118,6 @@ robotic_arm.UR:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -167,7 +140,7 @@ robotic_arm.UR:
       gripper_pose: float
       gripper_status: str
     type: python
-  description: UR robotic arm
+  description: Universal Robots机械臂设备，用于实验室精密操作和自动化作业。该设备集成了UR机械臂本体、Robotiq夹爪和RTDE通信接口，支持六自由度精确运动控制和力觉反馈。具备实时位置监控、状态反馈、轨迹规划等功能，可执行复杂的多点位运动任务。适用于样品抓取、精密装配、实验器具操作等需要高精度和高重复性的实验室自动化场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -197,3 +170,4 @@ robotic_arm.UR:
       - arm_status
       - gripper_status
       type: object
+  version: 0.0.1

unilabos/registry/devices/robot_gripper.yaml

@@ -51,7 +51,7 @@ gripper.misumi_rz:
         handles: []
         result: {}
         schema:
-          description: gripper_move的参数schema
+          description: 夹爪抓取运动控制函数。控制夹爪的开合运动，支持位置、速度、力矩的精确设定。位置参数控制夹爪开合程度，速度参数控制运动快慢，力矩参数控制夹持强度。该函数提供安全的力控制，避免损坏被抓取物体，适用于各种形状和材质的物品抓取。
           properties:
             feedback: {}
             goal:
@@ -80,7 +80,7 @@ gripper.misumi_rz:
         handles: []
         result: {}
         schema:
-          description: init_gripper的参数schema
+          description: 夹爪初始化函数。执行Misumi RZ夹爪的完整初始化流程，包括Modbus通信建立、电机参数配置、传感器校准等。该函数确保夹爪系统从安全状态恢复到可操作状态，是夹爪使用前的必要步骤。初始化完成后夹爪将处于就绪状态，可接收抓取和旋转指令。
           properties:
             feedback: {}
             goal:
@@ -169,7 +169,7 @@ gripper.misumi_rz:
         handles: []
         result: {}
         schema:
-          description: node_gripper_move的参数schema
+          description: 节点夹爪移动任务函数。接收逗号分隔的命令字符串，解析位置、速度、力矩参数并执行夹爪抓取动作。该函数等待运动完成并返回执行结果，提供同步的运动控制接口。适用于需要可靠完成确认的精密抓取操作。
           properties:
             feedback: {}
             goal:
@@ -193,7 +193,7 @@ gripper.misumi_rz:
         handles: []
         result: {}
         schema:
-          description: node_rotate_move的参数schema
+          description: 节点旋转移动任务函数。接收逗号分隔的命令字符串，解析角度、速度、力矩参数并执行夹爪旋转动作。该函数等待旋转完成并返回执行结果，提供同步的旋转控制接口。适用于需要精确角度定位和完成确认的旋转操作。
           properties:
             feedback: {}
             goal:
@@ -251,7 +251,7 @@ gripper.misumi_rz:
         handles: []
         result: {}
         schema:
-          description: rotate_move_abs的参数schema
+          description: 夹爪绝对位置旋转控制函数。控制夹爪主轴旋转到指定的绝对角度位置，支持360度连续旋转。位置参数指定目标角度，速度参数控制旋转速率，力矩参数设定旋转阻力限制。该函数提供高精度的角度定位，适用于需要精确方向控制的操作场景。
           properties:
             feedback: {}
             goal:
@@ -379,10 +379,9 @@ gripper.misumi_rz:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -391,7 +390,6 @@ gripper.misumi_rz:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -400,7 +398,6 @@ gripper.misumi_rz:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -420,7 +417,7 @@ gripper.misumi_rz:
     status_types:
       status: str
     type: python
-  description: Misumi RZ gripper
+  description: Misumi RZ系列电子夹爪设备，集成旋转和抓取双重功能的精密夹爪系统。该设备通过Modbus RTU协议与控制系统通信，支持位置、速度、力矩的精确控制。具备高精度的位置反馈、实时状态监控和故障检测功能。适用于需要精密抓取和旋转操作的实验室自动化场景，如样品管理、精密装配、器件操作等应用。
   handles: []
   icon: ''
   init_param_schema:
@@ -447,6 +444,7 @@ gripper.misumi_rz:
       required:
       - status
       type: object
+  version: 0.0.1
 gripper.mock:
   class:
     action_value_mappings:
@@ -461,7 +459,7 @@ gripper.mock:
         handles: []
         result: {}
         schema:
-          description: edit_id的参数schema
+          description: 模拟夹爪资源ID编辑函数。用于测试和演示资源管理功能，模拟修改夹爪资源的标识信息。该函数接收工作流名称、参数和资源对象，模拟真实的资源更新过程并返回修改后的资源信息。适用于系统测试和开发调试场景。
           properties:
             feedback: {}
             goal:
@@ -484,38 +482,6 @@ gripper.mock:
           title: edit_id参数
           type: object
         type: UniLabJsonCommand
-      auto-push_to:
-        feedback: {}
-        goal: {}
-        goal_default:
-          position: null
-          torque: null
-          velocity: 0.0
-        handles: []
-        result: {}
-        schema:
-          description: push_to的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                position:
-                  type: number
-                torque:
-                  type: number
-                velocity:
-                  default: 0.0
-                  type: number
-              required:
-              - position
-              - torque
-              type: object
-            result: {}
-          required:
-          - goal
-          title: push_to参数
-          type: object
-        type: UniLabJsonCommand
       push_to:
         feedback:
           effort: torque
@@ -532,10 +498,9 @@ gripper.mock:
           effort: torque
           position: position
         schema:
-          description: ROS Action GripperCommand 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 effort:
                   type: number
@@ -553,7 +518,6 @@ gripper.mock:
               title: GripperCommand_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   properties:
@@ -571,7 +535,6 @@ gripper.mock:
               title: GripperCommand_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 effort:
                   type: number
@@ -600,7 +563,7 @@ gripper.mock:
       torque: float
       velocity: float
     type: python
-  description: Mock gripper
+  description: 模拟夹爪设备，用于系统测试和开发调试。该设备模拟真实夹爪的位置、速度、力矩等物理特性，支持虚拟的抓取和移动操作。提供与真实夹爪相同的接口和状态反馈，便于在没有实际硬件的情况下进行系统集成测试和算法验证。适用于软件开发、系统调试和培训演示等场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -624,3 +587,4 @@ gripper.mock:
       - torque
       - status
       type: object
+  version: 0.0.1

unilabos/registry/devices/robot_linear_motion.yaml

@@ -8,7 +8,7 @@ linear_motion.grbl:
         handles: []
         result: {}
         schema:
-          description: initialize的参数schema
+          description: CNC设备初始化函数。执行Grbl CNC的完整初始化流程，包括归零操作、轴校准和状态复位。该函数将所有轴移动到原点位置(0,0,0)，确保设备处于已知的参考状态。初始化完成后设备进入空闲状态，可接收后续的运动指令。
           properties:
             feedback: {}
             goal:
@@ -21,30 +21,6 @@ linear_motion.grbl:
           title: initialize参数
           type: object
         type: UniLabJsonCommand
-      auto-move_through_points:
-        feedback: {}
-        goal: {}
-        goal_default:
-          positions: null
-        handles: []
-        result: {}
-        schema:
-          description: move_through_points的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                positions:
-                  type: array
-              required:
-              - positions
-              type: object
-            result: {}
-          required:
-          - goal
-          title: move_through_points参数
-          type: object
-        type: UniLabJsonCommand
       auto-set_position:
         feedback: {}
         goal: {}
@@ -53,7 +29,7 @@ linear_motion.grbl:
         handles: []
         result: {}
         schema:
-          description: set_position的参数schema
+          description: CNC绝对位置设定函数。控制CNC设备移动到指定的三维坐标位置(x,y,z)。该函数支持安全限位检查，防止超出设备工作范围。移动过程中会监控设备状态，确保安全到达目标位置。适用于精确定位和轨迹控制操作。
           properties:
             feedback: {}
             goal:
@@ -69,34 +45,6 @@ linear_motion.grbl:
           title: set_position参数
           type: object
         type: UniLabJsonCommand
-      auto-set_spindle_speed:
-        feedback: {}
-        goal: {}
-        goal_default:
-          max_velocity: 500
-          spindle_speed: null
-        handles: []
-        result: {}
-        schema:
-          description: set_spindle_speed的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                max_velocity:
-                  default: 500
-                  type: number
-                spindle_speed:
-                  type: number
-              required:
-              - spindle_speed
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_spindle_speed参数
-          type: object
-        type: UniLabJsonCommand
       auto-stop_operation:
         feedback: {}
         goal: {}
@@ -104,7 +52,7 @@ linear_motion.grbl:
         handles: []
         result: {}
         schema:
-          description: stop_operation的参数schema
+          description: CNC操作停止函数。立即停止当前正在执行的所有CNC运动，包括轴移动和主轴旋转。该函数用于紧急停止或任务中断，确保设备和工件的安全。停止后设备将保持当前位置，等待新的指令。
           properties:
             feedback: {}
             goal:
@@ -166,10 +114,9 @@ linear_motion.grbl:
         handles: []
         result: {}
         schema:
-          description: ROS Action NavigateThroughPoses 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_pose:
                   properties:
@@ -290,7 +237,6 @@ linear_motion.grbl:
               title: NavigateThroughPoses_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 behavior_tree:
                   type: string
@@ -371,7 +317,6 @@ linear_motion.grbl:
               title: NavigateThroughPoses_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 result:
                   properties: {}
@@ -401,10 +346,9 @@ linear_motion.grbl:
         handles: []
         result: {}
         schema:
-          description: ROS Action SingleJointPosition 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 error:
                   type: number
@@ -444,7 +388,6 @@ linear_motion.grbl:
               title: SingleJointPosition_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 max_velocity:
                   type: number
@@ -472,7 +415,6 @@ linear_motion.grbl:
               title: SingleJointPosition_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties: {}
               required: []
               title: SingleJointPosition_Result
@@ -488,7 +430,7 @@ linear_motion.grbl:
       spindle_speed: float
       status: str
     type: python
-  description: Grbl CNC
+  description: Grbl数控机床（CNC）设备，用于实验室精密加工和三轴定位操作。该设备基于Grbl固件，通过串口通信控制步进电机实现X、Y、Z三轴的精确运动。支持绝对定位、轨迹规划、主轴控制和实时状态监控。具备安全限位保护和运动平滑控制功能。适用于精密钻孔、铣削、雕刻、样品制备等需要高精度定位和加工的实验室应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -524,6 +466,7 @@ linear_motion.grbl:
       - position
       - spindle_speed
       type: object
+  version: 0.0.1
 motor.iCL42:
   class:
     action_value_mappings:
@@ -537,7 +480,7 @@ motor.iCL42:
         handles: []
         result: {}
         schema:
-          description: execute_run_motor的参数schema
+          description: 步进电机执行运动函数。直接执行电机运动命令，包括位置设定、速度控制和路径规划。该函数处理底层的电机控制协议，消除警告信息，设置运动参数并启动电机运行。适用于需要直接控制电机运动的应用场景。
           properties:
             feedback: {}
             goal:
@@ -566,7 +509,7 @@ motor.iCL42:
         handles: []
         result: {}
         schema:
-          description: init_device的参数schema
+          description: iCL42电机设备初始化函数。建立与iCL42步进电机驱动器的串口通信连接，配置通信参数包括波特率、数据位、校验位等。该函数是电机使用前的必要步骤，确保驱动器处于可控状态并准备接收运动指令。
           properties:
             feedback: {}
             goal:
@@ -589,7 +532,7 @@ motor.iCL42:
         handles: []
         result: {}
         schema:
-          description: run_motor的参数schema
+          description: 步进电机运动控制函数。根据指定的运动模式、目标位置和速度参数控制电机运动。支持多种运动模式和精确的位置控制，自动处理运动轨迹规划和执行。该函数提供异步执行和状态反馈，确保运动的准确性和可靠性。
           properties:
             feedback: {}
             goal:
@@ -621,10 +564,9 @@ motor.iCL42:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -633,7 +575,6 @@ motor.iCL42:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -642,7 +583,6 @@ motor.iCL42:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -664,7 +604,7 @@ motor.iCL42:
       motor_position: int
       success: bool
     type: python
-  description: iCL42 motor
+  description: iCL42步进电机驱动器，用于实验室设备的精密线性运动控制。该设备通过串口通信控制iCL42型步进电机驱动器，支持多种运动模式和精确的位置、速度控制。具备位置反馈、运行状态监控和故障检测功能。适用于自动进样器、样品传送、精密定位平台等需要准确线性运动控制的实验室自动化设备。
   handles: []
   icon: ''
   init_param_schema:
@@ -691,3 +631,4 @@ motor.iCL42:
       - is_executing_run
       - success
       type: object
+  version: 0.0.1

unilabos/registry/devices/sim_nodes.yaml

@@ -285,7 +285,7 @@ lh_joint_publisher:
     module: unilabos.devices.ros_dev.liquid_handler_joint_publisher:LiquidHandlerJointPublisher
     status_types: {}
     type: ros2
-  description: ''
+  description: 液体处理器关节发布器，用于ROS2仿真系统中的液体处理设备运动控制。该节点通过发布关节状态驱动仿真模型中的机械臂运动，支持三维坐标到关节空间的逆运动学转换、多关节协调控制、资源跟踪和TF变换。具备精确的位置控制、速度调节、pick-and-place操作等功能。适用于液体处理系统的虚拟仿真、运动规划验证、系统集成测试等应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -309,3 +309,4 @@ lh_joint_publisher:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/temperature.yaml

@@ -89,30 +89,6 @@ chiller:
           title: modbus_crc参数
           type: object
         type: UniLabJsonCommand
-      auto-set_temperature:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_temperature的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_temperature参数
-          type: object
-        type: UniLabJsonCommand
       auto-stop:
         feedback: {}
         goal: {}
@@ -143,10 +119,9 @@ chiller:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -155,7 +130,6 @@ chiller:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -164,7 +138,6 @@ chiller:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -183,7 +156,7 @@ chiller:
     module: unilabos.devices.temperature.chiller:Chiller
     status_types: {}
     type: python
-  description: Chiller
+  description: 实验室制冷设备，用于精确的温度控制和冷却操作。该设备通过Modbus RTU协议与控制系统通信，支持精确的温度设定和监控。具备快速降温、恒温控制和温度保持功能，广泛应用于需要低温环境的化学反应、样品保存、结晶操作等实验场景。提供稳定可靠的冷却性能，确保实验过程的温度精度。
   handles: []
   icon: ''
   init_param_schema:
@@ -201,6 +174,7 @@ chiller:
       properties: {}
       required: []
       type: object
+  version: 0.0.1
 heaterstirrer.dalong:
   class:
     action_value_mappings:
@@ -224,50 +198,6 @@ heaterstirrer.dalong:
           title: close参数
           type: object
         type: UniLabJsonCommand
-      auto-heatchill:
-        feedback: {}
-        goal: {}
-        goal_default:
-          purpose: reaction
-          stir: true
-          stir_speed: 300
-          temp: null
-          time: 3600
-          vessel: null
-        handles: []
-        result: {}
-        schema:
-          description: heatchill的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                purpose:
-                  default: reaction
-                  type: string
-                stir:
-                  default: true
-                  type: boolean
-                stir_speed:
-                  default: 300
-                  type: number
-                temp:
-                  type: number
-                time:
-                  default: 3600
-                  type: number
-                vessel:
-                  type: string
-              required:
-              - vessel
-              - temp
-              type: object
-            result: {}
-          required:
-          - goal
-          title: heatchill参数
-          type: object
-        type: UniLabJsonCommand
       auto-set_stir_speed:
         feedback: {}
         goal: {}
@@ -320,54 +250,6 @@ heaterstirrer.dalong:
           title: set_temp_inner参数
           type: object
         type: UniLabJsonCommand
-      auto-set_temp_target:
-        feedback: {}
-        goal: {}
-        goal_default:
-          temp: null
-        handles: []
-        result: {}
-        schema:
-          description: set_temp_target的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                temp:
-                  type: string
-              required:
-              - temp
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_temp_target参数
-          type: object
-        type: UniLabJsonCommand
-      auto-set_temp_warning:
-        feedback: {}
-        goal: {}
-        goal_default:
-          temp: null
-        handles: []
-        result: {}
-        schema:
-          description: set_temp_warning的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                temp:
-                  type: string
-              required:
-              - temp
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_temp_warning参数
-          type: object
-        type: UniLabJsonCommand
       heatchill:
         feedback:
           status: status
@@ -387,10 +269,9 @@ heaterstirrer.dalong:
         result:
           success: success
         schema:
-          description: ROS Action HeatChill 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -399,7 +280,6 @@ heaterstirrer.dalong:
               title: HeatChill_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 purpose:
                   type: string
@@ -423,7 +303,6 @@ heaterstirrer.dalong:
               title: HeatChill_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -449,10 +328,9 @@ heaterstirrer.dalong:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -461,7 +339,6 @@ heaterstirrer.dalong:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -470,7 +347,6 @@ heaterstirrer.dalong:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -496,10 +372,9 @@ heaterstirrer.dalong:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -508,7 +383,6 @@ heaterstirrer.dalong:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -517,7 +391,6 @@ heaterstirrer.dalong:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -541,7 +414,7 @@ heaterstirrer.dalong:
       temp_target: float
       temp_warning: float
     type: python
-  description: DaLong heater stirrer
+  description: 大龙加热搅拌器，集成加热和搅拌双重功能的实验室设备。该设备通过串口通信控制，支持精确的温度调节、搅拌速度控制和安全保护功能。具备实时温度监测、目标温度设定、安全温度报警等特性。适用于化学合成、样品制备、反应控制等需要同时进行加热和搅拌的实验操作，提供稳定均匀的反应环境。
   handles: []
   icon: ''
   init_param_schema:
@@ -577,6 +450,7 @@ heaterstirrer.dalong:
       - temp_warning
       - temp_target
       type: object
+  version: 0.0.1
 tempsensor:
   class:
     action_value_mappings:
@@ -688,30 +562,6 @@ tempsensor:
           title: send_prototype_command参数
           type: object
         type: UniLabJsonCommand
-      auto-set_warning:
-        feedback: {}
-        goal: {}
-        goal_default:
-          command: null
-        handles: []
-        result: {}
-        schema:
-          description: set_warning的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_warning参数
-          type: object
-        type: UniLabJsonCommand
       set_warning:
         feedback: {}
         goal:
@@ -722,10 +572,9 @@ tempsensor:
         result:
           success: success
         schema:
-          description: ROS Action SendCmd 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -734,7 +583,6 @@ tempsensor:
               title: SendCmd_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 command:
                   type: string
@@ -743,7 +591,6 @@ tempsensor:
               title: SendCmd_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -763,7 +610,7 @@ tempsensor:
     status_types:
       value: float
     type: python
-  description: Temperature sensor
+  description: 高精度温度传感器设备，用于实验室环境和设备的温度监测。该传感器通过Modbus RTU协议与控制系统通信，提供实时准确的温度数据。具备高精度测量、报警温度设定、数据稳定性好等特点。适用于反应器监控、环境温度监测、设备保护等需要精确温度测量的实验场景，为实验安全和数据可靠性提供保障。
   handles: []
   icon: ''
   init_param_schema:
@@ -790,3 +637,4 @@ tempsensor:
       required:
       - value
       type: object
+  version: 0.0.1

unilabos/registry/devices/vacuum_and_purge.yaml

@@ -1,26 +1,6 @@
 gas_source.mock:
   class:
     action_value_mappings:
-      auto-close:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: close的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: close参数
-          type: object
-        type: UniLabJsonCommand
       auto-is_closed:
         feedback: {}
         goal: {}
@@ -61,50 +41,6 @@ gas_source.mock:
           title: is_open参数
           type: object
         type: UniLabJsonCommand
-      auto-open:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: open的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: open参数
-          type: object
-        type: UniLabJsonCommand
-      auto-set_status:
-        feedback: {}
-        goal: {}
-        goal_default:
-          string: null
-        handles: []
-        result: {}
-        schema:
-          description: set_status的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                string:
-                  type: string
-              required:
-              - string
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_status参数
-          type: object
-        type: UniLabJsonCommand
       close:
         feedback: {}
         goal: {}
@@ -112,22 +48,19 @@ gas_source.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -147,22 +80,19 @@ gas_source.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -184,16 +114,14 @@ gas_source.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action StrSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 string:
                   type: string
@@ -202,7 +130,6 @@ gas_source.mock:
               title: StrSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -222,7 +149,7 @@ gas_source.mock:
     status_types:
       status: str
     type: python
-  description: Mock gas source
+  description: 模拟气体源设备，用于系统测试和开发调试。该设备模拟真实气体源的开关控制和状态监测功能，支持气体供应的启停操作。提供与真实气体源相同的接口和状态反馈，便于在没有实际硬件的情况下进行系统集成测试和算法验证。适用于气路系统调试、软件开发和实验流程验证等场景。
   handles:
   - data_key: fluid_out
     data_source: executor
@@ -246,29 +173,10 @@ gas_source.mock:
       required:
       - status
       type: object
+  version: 0.0.1
 vacuum_pump.mock:
   class:
     action_value_mappings:
-      auto-close:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: close的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: close参数
-          type: object
-        type: UniLabJsonCommand
       auto-is_closed:
         feedback: {}
         goal: {}
@@ -309,50 +217,6 @@ vacuum_pump.mock:
           title: is_open参数
           type: object
         type: UniLabJsonCommand
-      auto-open:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: open的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: open参数
-          type: object
-        type: UniLabJsonCommand
-      auto-set_status:
-        feedback: {}
-        goal: {}
-        goal_default:
-          string: null
-        handles: []
-        result: {}
-        schema:
-          description: set_status的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                string:
-                  type: string
-              required:
-              - string
-              type: object
-            result: {}
-          required:
-          - goal
-          title: set_status参数
-          type: object
-        type: UniLabJsonCommand
       close:
         feedback: {}
         goal: {}
@@ -360,22 +224,19 @@ vacuum_pump.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -395,22 +256,19 @@ vacuum_pump.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -432,16 +290,14 @@ vacuum_pump.mock:
         handles: []
         result: {}
         schema:
-          description: ROS Action StrSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 string:
                   type: string
@@ -450,7 +306,6 @@ vacuum_pump.mock:
               title: StrSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -470,7 +325,7 @@ vacuum_pump.mock:
     status_types:
       status: str
     type: python
-  description: Mock vacuum pump
+  description: 模拟真空泵设备，用于系统测试和开发调试。该设备模拟真实真空泵的抽气功能和状态控制，支持真空系统的启停操作和状态监测。提供与真实真空泵相同的接口和控制逻辑，便于在没有实际硬件的情况下进行真空系统的集成测试。适用于真空工艺调试、软件开发和实验流程验证等场景。
   handles:
   - data_key: fluid_in
     data_source: handle
@@ -494,3 +349,4 @@ vacuum_pump.mock:
       required:
       - status
       type: object
+  version: 0.0.1

unilabos/registry/devices/work_station.yaml

@@ -54,10 +54,9 @@ workstation:
         handles: []
         result: {}
         schema:
-          description: ROS Action AGVTransfer 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -66,7 +65,6 @@ workstation:
               title: AGVTransfer_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 from_repo:
                   properties:
@@ -226,7 +224,6 @@ workstation:
               title: AGVTransfer_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -286,10 +283,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Add 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_status:
                   type: string
@@ -301,7 +297,6 @@ workstation:
               title: Add_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 amount:
                   type: string
@@ -337,7 +332,6 @@ workstation:
               title: Add_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -386,10 +380,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action AdjustPH 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -401,7 +394,6 @@ workstation:
               title: AdjustPH_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 ph_value:
                   type: number
@@ -416,7 +408,6 @@ workstation:
               title: AdjustPH_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -462,10 +453,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Centrifuge 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_speed:
                   type: number
@@ -483,7 +473,6 @@ workstation:
               title: Centrifuge_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 speed:
                   type: number
@@ -501,7 +490,6 @@ workstation:
               title: Centrifuge_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -554,10 +542,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Clean 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_device:
                   type: string
@@ -601,7 +588,6 @@ workstation:
               title: Clean_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 repeats:
                   maximum: 2147483647
@@ -624,7 +610,6 @@ workstation:
               title: Clean_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -674,10 +659,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action CleanVessel 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -689,7 +673,6 @@ workstation:
               title: CleanVessel_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 repeats:
                   maximum: 2147483647
@@ -712,7 +695,6 @@ workstation:
               title: CleanVessel_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -769,10 +751,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Dissolve 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -784,7 +765,6 @@ workstation:
               title: Dissolve_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 amount:
                   type: string
@@ -811,7 +791,6 @@ workstation:
               title: Dissolve_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -853,10 +832,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Dry 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -868,7 +846,6 @@ workstation:
               title: Dry_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 compound:
                   type: string
@@ -880,7 +857,6 @@ workstation:
               title: Dry_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -903,7 +879,6 @@ workstation:
         feedback: {}
         goal:
           gas: gas
-          repeats: repeats
           vessel: vessel
         goal_default:
           gas: ''
@@ -924,10 +899,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action EvacuateAndRefill 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_device:
                   type: string
@@ -971,7 +945,6 @@ workstation:
               title: EvacuateAndRefill_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 gas:
                   type: string
@@ -988,7 +961,6 @@ workstation:
               title: EvacuateAndRefill_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1008,6 +980,7 @@ workstation:
         feedback: {}
         goal:
           pressure: pressure
+          solvent: solvent
           stir_speed: stir_speed
           temp: temp
           time: time
@@ -1023,20 +996,19 @@ workstation:
           - data_key: vessel
             data_source: handle
             data_type: resource
-            handler_key: Vessel
-            label: Vessel
+            handler_key: vessel
+            label: Evaporation Vessel
           output:
           - data_key: vessel
-            data_source: executor
+            data_source: handle
             data_type: resource
-            handler_key: VesselOut
-            label: Vessel
+            handler_key: vessel_out
+            label: Evaporation Vessel
         result: {}
         schema:
-          description: ROS Action Evaporate 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_device:
                   type: string
@@ -1080,7 +1052,6 @@ workstation:
               title: Evaporate_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 pressure:
                   type: number
@@ -1101,7 +1072,6 @@ workstation:
               title: Evaporate_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1142,7 +1112,7 @@ workstation:
             data_type: resource
             handler_key: Vessel
             label: Vessel
-          - data_key: vessel
+          - data_key: filtrate_vessel
             data_source: handle
             data_type: resource
             handler_key: filtrate_vessel
@@ -1153,17 +1123,16 @@ workstation:
             data_type: resource
             handler_key: VesselOut
             label: Vessel
-          - data_key: vessel
+          - data_key: filtrate_vessel
             data_source: executor
             data_type: resource
             handler_key: filtrate_out
             label: Filtrate Vessel
         result: {}
         schema:
-          description: ROS Action Filter 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_status:
                   type: string
@@ -1181,7 +1150,6 @@ workstation:
               title: Filter_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 continue_heatchill:
                   type: boolean
@@ -1208,7 +1176,6 @@ workstation:
               title: Filter_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -1275,10 +1242,9 @@ workstation:
             label: To Vessel
         result: {}
         schema:
-          description: ROS Action FilterThrough 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -1290,7 +1256,6 @@ workstation:
               title: FilterThrough_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 eluting_repeats:
                   maximum: 2147483647
@@ -1319,7 +1284,6 @@ workstation:
               title: FilterThrough_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -1341,11 +1305,15 @@ workstation:
       HeatChillProtocol:
         feedback: {}
         goal:
+          pressure: pressure
           purpose: purpose
+          reflux_solvent: reflux_solvent
           stir: stir
           stir_speed: stir_speed
           temp: temp
+          temp_spec: temp_spec
           time: time
+          time_spec: time_spec
           vessel: vessel
         goal_default:
           purpose: ''
@@ -1369,10 +1337,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action HeatChill 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -1381,7 +1348,6 @@ workstation:
               title: HeatChill_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 purpose:
                   type: string
@@ -1405,7 +1371,6 @@ workstation:
               title: HeatChill_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1446,10 +1411,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action HeatChillStart 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -1458,7 +1422,6 @@ workstation:
               title: HeatChillStart_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 purpose:
                   type: string
@@ -1473,7 +1436,6 @@ workstation:
               title: HeatChillStart_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1510,10 +1472,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action HeatChillStop 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -1522,7 +1483,6 @@ workstation:
               title: HeatChillStop_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 vessel:
                   type: string
@@ -1531,7 +1491,6 @@ workstation:
               title: HeatChillStop_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1572,10 +1531,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Hydrogenate 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -1587,7 +1545,6 @@ workstation:
               title: Hydrogenate_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 temp:
                   type: string
@@ -1602,7 +1559,6 @@ workstation:
               title: Hydrogenate_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -1625,13 +1581,18 @@ workstation:
         feedback: {}
         goal:
           amount: amount
+          event: event
+          flowrate: flowrate
           from_vessel: from_vessel
+          rate_spec: rate_spec
           rinsing_repeats: rinsing_repeats
           rinsing_solvent: rinsing_solvent
           rinsing_volume: rinsing_volume
           solid: solid
+          through: through
           time: time
           to_vessel: to_vessel
+          transfer_flowrate: transfer_flowrate
           viscous: viscous
           volume: volume
         goal_default:
@@ -1675,10 +1636,9 @@ workstation:
             label: To Vessel
         result: {}
         schema:
-          description: ROS Action PumpTransfer 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_device:
                   type: string
@@ -1722,7 +1682,6 @@ workstation:
               title: PumpTransfer_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 amount:
                   type: string
@@ -1760,7 +1719,6 @@ workstation:
               title: PumpTransfer_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -1797,12 +1755,12 @@ workstation:
             data_type: resource
             handler_key: Vessel
             label: Vessel
-          - data_key: solvent
+          - data_key: solvent1
             data_source: handle
             data_type: resource
             handler_key: solvent1
             label: Solvent 1
-          - data_key: solvent
+          - data_key: solvent2
             data_source: handle
             data_type: resource
             handler_key: solvent2
@@ -1815,10 +1773,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Recrystallize 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -1830,7 +1787,6 @@ workstation:
               title: Recrystallize_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 ratio:
                   type: string
@@ -1851,7 +1807,6 @@ workstation:
               title: Recrystallize_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -1886,10 +1841,9 @@ workstation:
           output: []
         result: {}
         schema:
-          description: ROS Action ResetHandling 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -1901,7 +1855,6 @@ workstation:
               title: ResetHandling_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 solvent:
                   type: string
@@ -1910,7 +1863,6 @@ workstation:
               title: ResetHandling_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -1964,10 +1916,9 @@ workstation:
             label: To Vessel
         result: {}
         schema:
-          description: ROS Action RunColumn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -1979,7 +1930,6 @@ workstation:
               title: RunColumn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 column:
                   type: string
@@ -1994,7 +1944,6 @@ workstation:
               title: RunColumn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -2073,10 +2022,9 @@ workstation:
             label: To Vessel
         result: {}
         schema:
-          description: ROS Action Separate 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_device:
                   type: string
@@ -2120,7 +2068,6 @@ workstation:
               title: Separate_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 from_vessel:
                   type: string
@@ -2167,7 +2114,6 @@ workstation:
               title: Separate_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -2208,10 +2154,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action StartStir 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_speed:
                   type: number
@@ -2226,7 +2171,6 @@ workstation:
               title: StartStir_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 purpose:
                   type: string
@@ -2241,7 +2185,6 @@ workstation:
               title: StartStir_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -2263,9 +2206,13 @@ workstation:
       StirProtocol:
         feedback: {}
         goal:
+          event: event
           settling_time: settling_time
           stir_speed: stir_speed
           stir_time: stir_time
+          time: time
+          time_spec: time_spec
+          vessel: vessel
         goal_default:
           settling_time: 0.0
           stir_speed: 0.0
@@ -2285,10 +2232,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action Stir 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 status:
                   type: string
@@ -2297,7 +2243,6 @@ workstation:
               title: Stir_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 settling_time:
                   type: number
@@ -2312,7 +2257,6 @@ workstation:
               title: Stir_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -2349,10 +2293,9 @@ workstation:
             label: Vessel
         result: {}
         schema:
-          description: ROS Action StopStir 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_status:
                   type: string
@@ -2364,7 +2307,6 @@ workstation:
               title: StopStir_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 vessel:
                   type: string
@@ -2373,7 +2315,6 @@ workstation:
               title: StopStir_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -2446,10 +2387,9 @@ workstation:
             label: To Vessel
         result: {}
         schema:
-          description: ROS Action Transfer 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 current_status:
                   type: string
@@ -2464,7 +2404,6 @@ workstation:
               title: Transfer_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 amount:
                   type: string
@@ -2502,7 +2441,6 @@ workstation:
               title: Transfer_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -2555,8 +2493,8 @@ workstation:
             data_type: resource
             handler_key: solvent
             label: Solvent
-          - data_key: vessel
-            data_source: executor
+          - data_key: filtrate_vessel
+            data_source: handle
             data_type: resource
             handler_key: filtrate_vessel
             label: Filtrate Vessel
@@ -2566,17 +2504,16 @@ workstation:
             data_type: resource
             handler_key: VesselOut
             label: Vessel Out
-          - data_key: vessel
+          - data_key: filtrate_vessel
             data_source: executor
             data_type: resource
             handler_key: filtrate_vessel_out
             label: Filtrate Vessel
         result: {}
         schema:
-          description: ROS Action WashSolid 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties:
                 progress:
                   type: number
@@ -2588,7 +2525,6 @@ workstation:
               title: WashSolid_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 filtrate_vessel:
                   type: string
@@ -2623,7 +2559,6 @@ workstation:
               title: WashSolid_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 message:
                   type: string
@@ -2757,3 +2692,4 @@ workstation:
       properties: {}
       required: []
       type: object
+  version: 0.0.1

unilabos/registry/devices/zhida_hplc.yaml

@@ -8,22 +8,19 @@ zhida_hplc:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -36,26 +33,6 @@ zhida_hplc:
           title: EmptyIn
           type: object
         type: EmptyIn
-      auto-abort:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result: {}
-        schema:
-          description: abort的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: abort参数
-          type: object
-        type: UniLabJsonCommand
       auto-close:
         feedback: {}
         goal: {}
@@ -63,7 +40,7 @@ zhida_hplc:
         handles: []
         result: {}
         schema:
-          description: close的参数schema
+          description: HPLC设备连接关闭函数。安全地断开与智达HPLC设备的TCP socket连接，释放网络资源。该函数确保连接的正确关闭，避免网络资源泄露。通常在设备使用完毕或系统关闭时调用。
           properties:
             feedback: {}
             goal:
@@ -83,7 +60,7 @@ zhida_hplc:
         handles: []
         result: {}
         schema:
-          description: connect的参数schema
+          description: HPLC设备连接建立函数。与智达HPLC设备建立TCP socket通信连接，配置通信超时参数。该函数是设备使用前的必要步骤，建立成功后可进行状态查询、方法获取、任务启动等操作。连接失败时会抛出异常。
           properties:
             feedback: {}
             goal:
@@ -96,30 +73,6 @@ zhida_hplc:
           title: connect参数
           type: object
         type: UniLabJsonCommand
-      auto-start:
-        feedback: {}
-        goal: {}
-        goal_default:
-          text: null
-        handles: []
-        result: {}
-        schema:
-          description: start的参数schema
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                text:
-                  type: string
-              required:
-              - text
-              type: object
-            result: {}
-          required:
-          - goal
-          title: start参数
-          type: object
-        type: UniLabJsonCommand
       get_methods:
         feedback: {}
         goal: {}
@@ -127,22 +80,19 @@ zhida_hplc:
         handles: []
         result: {}
         schema:
-          description: ROS Action EmptyIn 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: EmptyIn_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties: {}
               required: []
               title: EmptyIn_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -164,16 +114,14 @@ zhida_hplc:
         handles: []
         result: {}
         schema:
-          description: ROS Action StrSingleInput 的 JSON Schema
+          description: ''
           properties:
             feedback:
-              description: Action 反馈 - 执行过程中从服务器发送到客户端
               properties: {}
               required: []
               title: StrSingleInput_Feedback
               type: object
             goal:
-              description: Action 目标 - 从客户端发送到服务器
               properties:
                 string:
                   type: string
@@ -182,7 +130,6 @@ zhida_hplc:
               title: StrSingleInput_Goal
               type: object
             result:
-              description: Action 结果 - 完成后从服务器发送到客户端
               properties:
                 return_info:
                   type: string
@@ -203,7 +150,7 @@ zhida_hplc:
       methods: dict
       status: dict
     type: python
-  description: Zhida HPLC
+  description: 智达高效液相色谱（HPLC）分析设备，用于实验室样品的分离、检测和定量分析。该设备通过TCP socket与HPLC控制系统通信，支持远程控制和状态监控。具备自动进样、梯度洗脱、多检测器数据采集等功能，可执行复杂的色谱分析方法。适用于化学分析、药物检测、环境监测、生物样品分析等需要高精度分离分析的实验室应用场景。
   handles: []
   icon: ''
   init_param_schema:
@@ -230,3 +177,4 @@ zhida_hplc:
       - status
       - methods
       type: object
+  version: 0.0.1

unilabos/registry/registry.py

@@ -2,6 +2,8 @@ import copy
 import io
 import os
 import sys
+import inspect
+import importlib
 from pathlib import Path
 from typing import Any, Dict, List
 
@@ -63,7 +65,7 @@ class Registry:
                                 },
                                 "feedback": {},
                                 "result": {"success": "success"},
-                                "schema": ros_action_to_json_schema(self.ResourceCreateFromOuter),
+                                "schema": ros_action_to_json_schema(self.ResourceCreateFromOuter, '用于创建或更新物料资源，每次传入多个物料信息。'),
                                 "goal_default": yaml.safe_load(
                                     io.StringIO(get_yaml_from_goal_type(self.ResourceCreateFromOuter.Goal))
                                 ),
@@ -84,7 +86,7 @@ class Registry:
                                 },
                                 "feedback": {},
                                 "result": {"success": "success"},
-                                "schema": ros_action_to_json_schema(self.ResourceCreateFromOuterEasy),
+                                "schema": ros_action_to_json_schema(self.ResourceCreateFromOuterEasy, '用于创建或更新物料资源，每次传入一个物料信息。'),
                                 "goal_default": yaml.safe_load(
                                     io.StringIO(get_yaml_from_goal_type(self.ResourceCreateFromOuterEasy.Goal))
                                 ),
@@ -99,18 +101,25 @@ class Registry:
                                         }
                                     ]
                                 },
+                                # todo: support nested keys, switch to non ros message schema
+                                "placeholder_keys": {
+                                    "res_id": "unilabos_resources",  # 将当前实验室的全部物料id作为下拉框可选择
+                                    "device_id": "unilabos_devices",  # 将当前实验室的全部设备id作为下拉框可选择
+                                    "parent": "unilabos_devices",  # 将当前实验室的全部设备id作为下拉框可选择
+                                },
                             },
                             "test_latency": {
                                 "type": self.EmptyIn,
                                 "goal": {},
                                 "feedback": {},
                                 "result": {"latency_ms": "latency_ms", "time_diff_ms": "time_diff_ms"},
-                                "schema": ros_action_to_json_schema(self.EmptyIn),
+                                "schema": ros_action_to_json_schema(self.EmptyIn, '用于测试延迟的动作，返回延迟时间和时间差。'),
                                 "goal_default": {},
                                 "handles": {},
                             },
                         },
                     },
+                    "version": "0.0.1",
                     "icon": "icon_device.webp",
                     "registry_type": "device",
                     "handles": [],
@@ -161,6 +170,54 @@ class Registry:
             else:
                 logger.debug(f"[UniLab Registry] Res File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}")
 
+    def _extract_class_docstrings(self, module_string: str) -> Dict[str, str]:
+        """
+        从模块字符串中提取类和方法的docstring信息
+
+        Args:
+            module_string: 模块字符串，格式为 "module.path:ClassName"
+
+        Returns:
+            包含类和方法docstring信息的字典
+        """
+        docstrings = {"class_docstring": "", "methods": {}}
+
+        if not module_string or ":" not in module_string:
+            return docstrings
+
+        try:
+            module_path, class_name = module_string.split(":", 1)
+
+            # 动态导入模块
+            module = importlib.import_module(module_path)
+
+            # 获取类
+            if hasattr(module, class_name):
+                cls = getattr(module, class_name)
+
+                # 获取类的docstring
+                class_doc = inspect.getdoc(cls)
+                if class_doc:
+                    docstrings["class_docstring"] = class_doc.strip()
+
+                # 获取所有方法的docstring
+                for method_name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+                    method_doc = inspect.getdoc(method)
+                    if method_doc:
+                        docstrings["methods"][method_name] = method_doc.strip()
+
+                # 也获取属性方法的docstring
+                for method_name, method in inspect.getmembers(cls, predicate=lambda x: isinstance(x, property)):
+                    if hasattr(method, "fget") and method.fget:
+                        method_doc = inspect.getdoc(method.fget)
+                        if method_doc:
+                            docstrings["methods"][method_name] = method_doc.strip()
+
+        except Exception as e:
+            logger.warning(f"[UniLab Registry] 无法提取docstring信息，模块: {module_string}, 错误: {str(e)}")
+
+        return docstrings
+
     def _replace_type_with_class(self, type_name: str, device_id: str, field_name: str) -> Any:
         """
         将类型名称替换为实际的类对象
@@ -274,15 +331,13 @@ class Registry:
             param_type = arg_info.get("type", "")
             param_default = arg_info.get("default")
             param_required = arg_info.get("required", True)
-            schema["properties"][param_name] = self._generate_schema_from_info(
-                param_name, param_type, param_default
-            )
+            schema["properties"][param_name] = self._generate_schema_from_info(param_name, param_type, param_default)
             if param_required:
                 schema["required"].append(param_name)
 
         return {
             "title": f"{method_name}参数",
-            "description": f"{method_name}的参数schema",
+            "description": f"",
             "type": "object",
             "properties": {"goal": schema, "feedback": {}, "result": {}},
             "required": ["goal"],
@@ -313,6 +368,8 @@ class Registry:
                 # 在添加到注册表前处理类型替换
                 for device_id, device_config in data.items():
                     # 添加文件路径信息 - 使用规范化的完整文件路径
+                    if "version" not in device_config:
+                        device_config["version"] = "0.0.1"
                     if "description" not in device_config:
                         device_config["description"] = ""
                     if "icon" not in device_config:
@@ -348,6 +405,14 @@ class Registry:
                             sorted(device_config["class"]["status_types"].items())
                         )
                         if complete_registry:
+                            # 保存原有的description信息
+                            old_descriptions = {}
+                            for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                                if "description" in action_config.get("schema", {}):
+                                    description = action_config["schema"]["description"]
+                                    if len(description):
+                                        old_descriptions[action_name] = action_config["schema"]["description"]
+
                             device_config["class"]["action_value_mappings"] = {
                                 k: v
                                 for k, v in device_config["class"]["action_value_mappings"].items()
@@ -365,9 +430,16 @@ class Registry:
                                         "goal_default": {i["name"]: i["default"] for i in v["args"]},
                                         "handles": [],
                                     }
+                                    # 不生成已配置action的动作
                                     for k, v in enhanced_info["action_methods"].items()
+                                    if k not in device_config["class"]["action_value_mappings"]
                                 }
                             )
+
+                            # 恢复原有的description信息（auto开头的不修改）
+                            for action_name, description in old_descriptions.items():
+                                if action_name in device_config["class"]["action_value_mappings"]:  # 有一些会被删除
+                                    device_config["class"]["action_value_mappings"][action_name]["schema"]["description"] = description
                             device_config["init_param_schema"] = {}
                             device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
                                 enhanced_info["init_params"], "__init__"
@@ -471,6 +543,13 @@ class Registry:
                                 },
                                 **schema["properties"]["goal"]["properties"],
                             }
+                    # 将 placeholder_keys 信息添加到 schema 中
+                    if "placeholder_keys" in action_config and action_config.get("schema", {}).get(
+                        "properties", {}
+                    ).get("goal", {}):
+                        action_config["schema"]["properties"]["goal"]["_unilabos_placeholder_info"] = action_config[
+                            "placeholder_keys"
+                        ]
 
             msg = {"id": device_id, **device_info_copy}
             devices.append(msg)

unilabos/ros/msgs/message_converter.py

@@ -132,7 +132,11 @@ _msg_converter: Dict[Type, Any] = {
     Bool: lambda x: Bool(data=bool(x)),
     str: str,
     String: lambda x: String(data=str(x)),
-    Point: lambda x: Point(x=x.x, y=x.y, z=x.z) if not isinstance(x, dict) else Point(x=float(x.get("x", 0.0)), y=float(x.get("y", 0.0)), z=float(x.get("z", 0.0))),
+    Point: lambda x: (
+        Point(x=x.x, y=x.y, z=x.z)
+        if not isinstance(x, dict)
+        else Point(x=float(x.get("x", 0.0)), y=float(x.get("y", 0.0)), z=float(x.get("z", 0.0)))
+    ),
     Resource: lambda x: Resource(
         id=x.get("id", ""),
         name=x.get("name", ""),
@@ -142,7 +146,13 @@ _msg_converter: Dict[Type, Any] = {
         type=x.get("type", ""),
         category=x.get("class", "") or x.get("type", ""),
         pose=(
-            Pose(position=Point(x=float(x.get("position", {}).get("x", 0.0)), y=float(x.get("position", {}).get("y", 0.0)), z=float(x.get("position", {}).get("z", 0.0))))
+            Pose(
+                position=Point(
+                    x=float(x.get("position", {}).get("x", 0.0)),
+                    y=float(x.get("position", {}).get("y", 0.0)),
+                    z=float(x.get("position", {}).get("z", 0.0)),
+                )
+            )
             if x.get("position", None) is not None
             else Pose()
         ),
@@ -151,6 +161,7 @@ _msg_converter: Dict[Type, Any] = {
     ),
 }
 
+
 def json_or_yaml_loads(data: str) -> Any:
     try:
         return json.loads(data)
@@ -161,6 +172,7 @@ def json_or_yaml_loads(data: str) -> Any:
             pass
         raise e
 
+
 # ROS消息到Python转换器
 _msg_converter_back: Dict[Type, Any] = {
     float: float,
@@ -571,30 +583,30 @@ from unilabos.utils.import_manager import ImportManager
 from unilabos.config.config import ROSConfig
 
 basic_type_map = {
-    'bool': {'type': 'boolean'},
-    'int8': {'type': 'integer', 'minimum': -128, 'maximum': 127},
-    'uint8': {'type': 'integer', 'minimum': 0, 'maximum': 255},
-    'int16': {'type': 'integer', 'minimum': -32768, 'maximum': 32767},
-    'uint16': {'type': 'integer', 'minimum': 0, 'maximum': 65535},
-    'int32': {'type': 'integer', 'minimum': -2147483648, 'maximum': 2147483647},
-    'uint32': {'type': 'integer', 'minimum': 0, 'maximum': 4294967295},
-    'int64': {'type': 'integer'},
-    'uint64': {'type': 'integer', 'minimum': 0},
-    'double': {'type': 'number'},
-    'float': {'type': 'number'},
-    'float32': {'type': 'number'},
-    'float64': {'type': 'number'},
-    'string': {'type': 'string'},
-    'boolean': {'type': 'boolean'},
-    'char': {'type': 'string', 'maxLength': 1},
-    'byte': {'type': 'integer', 'minimum': 0, 'maximum': 255},
+    "bool": {"type": "boolean"},
+    "int8": {"type": "integer", "minimum": -128, "maximum": 127},
+    "uint8": {"type": "integer", "minimum": 0, "maximum": 255},
+    "int16": {"type": "integer", "minimum": -32768, "maximum": 32767},
+    "uint16": {"type": "integer", "minimum": 0, "maximum": 65535},
+    "int32": {"type": "integer", "minimum": -2147483648, "maximum": 2147483647},
+    "uint32": {"type": "integer", "minimum": 0, "maximum": 4294967295},
+    "int64": {"type": "integer"},
+    "uint64": {"type": "integer", "minimum": 0},
+    "double": {"type": "number"},
+    "float": {"type": "number"},
+    "float32": {"type": "number"},
+    "float64": {"type": "number"},
+    "string": {"type": "string"},
+    "boolean": {"type": "boolean"},
+    "char": {"type": "string", "maxLength": 1},
+    "byte": {"type": "integer", "minimum": 0, "maximum": 255},
 }
 
 
-def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str=None) -> Dict[str, Any]:
+def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str = None) -> Dict[str, Any]:
     """
     将 ROS 字段类型转换为 JSON Schema 类型定义
-    
+
     Args:
         type_info: ROS 类型
         slot_type: ROS 类型
@@ -603,10 +615,7 @@ def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str=None) ->
         对应的 JSON Schema 类型定义
     """
     if isinstance(type_info, UnboundedSequence):
-        return {
-            'type': 'array',
-            'items': ros_field_type_to_json_schema(type_info.value_type)
-        }
+        return {"type": "array", "items": ros_field_type_to_json_schema(type_info.value_type)}
     if isinstance(type_info, NamespacedType):
         cls_name = ".".join(type_info.namespaces) + ":" + type_info.name
         type_class = msg_converter_manager.get_class(cls_name)
@@ -614,20 +623,20 @@ def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str=None) ->
     elif isinstance(type_info, BasicType):
         return ros_field_type_to_json_schema(type_info.typename)
     elif isinstance(type_info, UnboundedString):
-        return basic_type_map['string']
+        return basic_type_map["string"]
     elif isinstance(type_info, str):
         if type_info in basic_type_map:
             return basic_type_map[type_info]
 
         # 处理时间和持续时间类型
-        if type_info in ('time', 'duration', 'builtin_interfaces/Time', 'builtin_interfaces/Duration'):
+        if type_info in ("time", "duration", "builtin_interfaces/Time", "builtin_interfaces/Duration"):
             return {
-                'type': 'object',
-                'properties': {
-                    'sec': {'type': 'integer', 'description': '秒'},
-                    'nanosec': {'type': 'integer', 'description': '纳秒'}
+                "type": "object",
+                "properties": {
+                    "sec": {"type": "integer", "description": "秒"},
+                    "nanosec": {"type": "integer", "description": "纳秒"},
                 },
-                'required': ['sec', 'nanosec']
+                "required": ["sec", "nanosec"],
             }
     else:
         return ros_message_to_json_schema(type_info)
@@ -638,9 +647,7 @@ def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str=None) ->
     #         'type': 'array',
     #         'items': ros_field_type_to_json_schema(item_type)
     #     }
-    
 
-    
     # # 处理复杂类型（尝试加载并处理）
     # try:
     #     # 如果它是一个完整的消息类型规范 (包名/msg/类型名)
@@ -655,34 +662,31 @@ def ros_field_type_to_json_schema(type_info: Type | str, slot_type: str=None) ->
     #     logger.debug(f"无法解析类型 {field_type}: {str(e)}")
     # return {'type': 'object', 'description': f'未知类型: {field_type}'}
 
+
 def ros_message_to_json_schema(msg_class: Any) -> Dict[str, Any]:
     """
     将 ROS 消息类转换为 JSON Schema
-    
+
     Args:
         msg_class: ROS 消息类
-        
+
     Returns:
         对应的 JSON Schema 定义
     """
-    schema = {
-        'type': 'object',
-        'properties': {},
-        'required': []
-    }
-    
+    schema = {"type": "object", "properties": {}, "required": []}
+
     # 获取类名作为标题
-    if hasattr(msg_class, '__name__'):
-        schema['title'] = msg_class.__name__
-    
+    if hasattr(msg_class, "__name__"):
+        schema["title"] = msg_class.__name__
+
     # 获取消息的字段和字段类型
     try:
         for ind, slot_info in enumerate(msg_class._fields_and_field_types.items()):
             slot_name, slot_type = slot_info
             type_info = msg_class.SLOT_TYPES[ind]
             field_schema = ros_field_type_to_json_schema(type_info, slot_type)
-            schema['properties'][slot_name] = field_schema
-            schema['required'].append(slot_name)
+            schema["properties"][slot_name] = field_schema
+            schema["required"].append(slot_name)
         # if hasattr(msg_class, 'get_fields_and_field_types'):
         #     fields_and_types = msg_class.get_fields_and_field_types()
         #
@@ -707,61 +711,66 @@ def ros_message_to_json_schema(msg_class: Any) -> Dict[str, Any]:
         #             schema['required'].append(clean_name)
     except Exception as e:
         # 如果获取字段类型失败，添加错误信息
-        schema['description'] = f"解析消息字段时出错: {str(e)}"
+        schema["description"] = f"解析消息字段时出错: {str(e)}"
         logger.error(f"解析 {msg_class.__name__} 消息字段失败: {str(e)}")
-    
+
     return schema
 
-def ros_action_to_json_schema(action_class: Any) -> Dict[str, Any]:
+
+def ros_action_to_json_schema(action_class: Any, description="") -> Dict[str, Any]:
     """
     将 ROS Action 类转换为 JSON Schema
-    
+
     Args:
         action_class: ROS Action 类
-        
+        description: 描述
+
     Returns:
         完整的 JSON Schema 定义
     """
-    if not hasattr(action_class, 'Goal') or not hasattr(action_class, 'Feedback') or not hasattr(action_class, 'Result'):
+    if (
+        not hasattr(action_class, "Goal")
+        or not hasattr(action_class, "Feedback")
+        or not hasattr(action_class, "Result")
+    ):
         raise ValueError(f"{action_class.__name__} 不是有效的 ROS Action 类")
-    
+
     # 创建基础 schema
     schema = {
-        'title': action_class.__name__,
-        'description': f"ROS Action {action_class.__name__} 的 JSON Schema",
-        'type': 'object',
-        'properties': {
-            'goal': {
-                'description': 'Action 目标 - 从客户端发送到服务器',
+        "title": action_class.__name__,
+        "description": description,
+        "type": "object",
+        "properties": {
+            "goal": {
+                # 'description': 'Action 目标 - 从客户端发送到服务器',
                 **ros_message_to_json_schema(action_class.Goal)
             },
-            'feedback': {
-                'description': 'Action 反馈 - 执行过程中从服务器发送到客户端',
+            "feedback": {
+                # 'description': 'Action 反馈 - 执行过程中从服务器发送到客户端',
                 **ros_message_to_json_schema(action_class.Feedback)
             },
-            'result': {
-                'description': 'Action 结果 - 完成后从服务器发送到客户端',
+            "result": {
+                # 'description': 'Action 结果 - 完成后从服务器发送到客户端',
                 **ros_message_to_json_schema(action_class.Result)
-            }
+            },
         },
-        'required': ['goal']
+        "required": ["goal"],
     }
-    
+
     return schema
 
+
 def convert_ros_action_to_jsonschema(
-    action_name_or_type: Union[str, Type],
-    output_file: Optional[str] = None,
-    format: str = 'json'
+    action_name_or_type: Union[str, Type], output_file: Optional[str] = None, format: str = "json"
 ) -> Dict[str, Any]:
     """
     将 ROS Action 类型转换为 JSON Schema，并可选地保存到文件
-    
+
     Args:
         action_name_or_type: ROS Action 类型名称或类
         output_file: 可选，输出 JSON Schema 的文件路径
         format: 输出格式，'json' 或 'yaml'
-        
+
     Returns:
         JSON Schema 定义（字典）
     """
@@ -771,21 +780,21 @@ def convert_ros_action_to_jsonschema(
         action_type = get_ros_type_by_msgname(action_name_or_type)
     else:
         action_type = action_name_or_type
-    
+
     # 生成 JSON Schema
     schema = ros_action_to_json_schema(action_type)
-    
+
     # 如果指定了输出文件，将 Schema 保存到文件
     if output_file:
-        if format.lower() == 'json':
-            with open(output_file, 'w', encoding='utf-8') as f:
+        if format.lower() == "json":
+            with open(output_file, "w", encoding="utf-8") as f:
                 json.dump(schema, f, indent=2, ensure_ascii=False)
-        elif format.lower() == 'yaml':
-            with open(output_file, 'w', encoding='utf-8') as f:
+        elif format.lower() == "yaml":
+            with open(output_file, "w", encoding="utf-8") as f:
                 yaml.safe_dump(schema, f, default_flow_style=False, allow_unicode=True)
         else:
             raise ValueError(f"不支持的格式: {format}，请使用 'json' 或 'yaml'")
-    
+
     return schema
 
 
@@ -794,14 +803,14 @@ if __name__ == "__main__":
     # 示例：转换 NavigateToPose action
     try:
         from nav2_msgs.action import NavigateToPose
-        
+
         # 转换为 JSON Schema 并打印
         schema = convert_ros_action_to_jsonschema(NavigateToPose)
         print(json.dumps(schema, indent=2, ensure_ascii=False))
-        
+
         # 保存到文件
         # convert_ros_action_to_jsonschema(NavigateToPose, "navigate_to_pose_schema.json")
-        
+
         # 或者使用字符串形式的 action 名称
         # schema = convert_ros_action_to_jsonschema("nav2_msgs/action/NavigateToPose")
     except ImportError:

unilabos/ros/nodes/base_device_node.py

@@ -307,7 +307,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         # 创建动作服务
         if self.create_action_server:
             for action_name, action_value_mapping in self._action_value_mappings.items():
-                if action_name.startswith("auto-"):
+                if action_name.startswith("auto-") or str(action_value_mapping.get("type", "")).startswith("UniLabJsonCommand"):
                     continue
                 self.create_ros_action_server(action_name, action_value_mapping)
 

unilabos/ros/nodes/presets/host_node.py

@@ -459,7 +459,7 @@ class HostNode(BaseROS2DeviceNode):
         self.devices_instances[device_id] = d
         # noinspection PyProtectedMember
         for action_name, action_value_mapping in d._ros_node._action_value_mappings.items():
-            if action_name.startswith("auto-"):
+            if action_name.startswith("auto-") or str(action_value_mapping.get("type", "")).startswith("UniLabJsonCommand"):
                 continue
             action_id = f"/devices/{device_id}/{action_name}"
             if action_id not in self._action_clients:

unilabos/ros/nodes/presets/protocol_node.py

@@ -134,7 +134,7 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
         if d is not None and hasattr(d, "ros_node_instance"):
             node = d.ros_node_instance
             for action_name, action_mapping in node._action_value_mappings.items():
-                if action_name.startswith("auto-"):
+                if action_name.startswith("auto-") or str(action_mapping.get("type", "")).startswith("UniLabJsonCommand"):
                     continue
                 action_id = f"/devices/{device_id_abs}/{action_name}"
                 if action_id not in self._action_clients:
@@ -211,7 +211,7 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
                 # 逐步执行工作流
                 step_results = []
                 for i, action in enumerate(protocol_steps):
-                    self.get_logger().info(f"Running step {i + 1}: {action}")
+                    # self.get_logger().info(f"Running step {i + 1}: {action}")
                     if isinstance(action, dict):
                         # 如果是单个动作，直接执行
                         if action["action_name"] == "wait":

unilabos_msgs/CMakeLists.txt

@@ -41,6 +41,7 @@ set(action_files
   "action/WashSolid.action"
   "action/Filter.action"
   "action/Add.action"
+  "action/AddSolid.action"
   "action/Centrifuge.action"
   "action/Crystallize.action"
   "action/Purge.action"

unilabos_msgs/action/Add.action

@@ -1,14 +1,19 @@
 # Goal - 添加试剂的目标参数  
-string vessel                    # 目标容器  
-string reagent                   # 试剂名称  
-float64 volume                   # 体积 (可选)  
-float64 mass                     # 质量 (可选)    
-string amount                    # 数量描述 (可选)  
-float64 time                     # 添加时间 (可选)  
-bool stir                        # 是否搅拌  
-float64 stir_speed              # 搅拌速度 (可选)  
-bool viscous                     # 是否为粘性液体  
-string purpose                   # 添加目的 (可选)  
+string vessel                    # 目标容器（必需）
+string reagent                   # 试剂名称（必需）
+string volume                    # 体积（如 "2.7 mL"，可选）
+string mass                      # 质量（如 "19.3 g"，可选）
+string amount                    # 数量描述（可选）
+string time                      # 添加时间（如 "1 h", "20 min"，可选）
+bool stir                        # 是否搅拌（可选）
+float64 stir_speed              # 搅拌速度 (RPM，可选)
+bool viscous                     # 是否为粘性液体（可选）
+string purpose                   # 添加目的（可选）
+string event                     # 事件标识（如 'A', 'B'，可选）
+string mol                       # 摩尔数（如 '0.28 mol', '16.2 mmol'，可选）
+string rate_spec                 # 速率规格（如 'portionwise', 'dropwise'，可选）
+string equiv                     # 当量（如 '1.1'，可选）
+string ratio                     # 比例（如 '1:1'，可选）
 ---
 # Result - 操作结果  
 bool success                     # 操作是否成功  

unilabos_msgs/action/AddSolid.action

@@ -0,0 +1,15 @@
+# Goal - 固体加样操作的目标参数
+string vessel                    # 目标容器（必需）
+string reagent                   # 试剂名称（必需）
+string mass                      # 质量字符串（如 "2.9 g"，可选）
+string mol                       # 摩尔数字符串（如 "0.12 mol"，可选）
+string purpose                   # 添加目的（可选）
+---
+# Result - 操作结果
+bool success                     # 操作是否成功
+string message                   # 结果消息
+string return_info               # 返回信息
+---
+# Feedback - 实时反馈
+string current_status           # 当前状态描述
+float64 progress                # 进度百分比 (0-100)

unilabos_msgs/action/Dissolve.action

@@ -1,14 +1,21 @@
-string vessel                   # 装有要溶解物质的容器名称
-string solvent                  # 用于溶解物质的溶剂名称
-float64 volume                  # 溶剂的体积，可选参数
-string amount                   # 要溶解物质的量，可选参数
-float64 temp                    # 溶解时的温度，可选参数
-float64 time                    # 溶解的时间，可选参数
-float64 stir_speed              # 搅拌速度，可选参数
+# Goal - 溶解操作的目标参数
+string vessel                   # 装有要溶解物质的容器名称（必需）
+string solvent                  # 用于溶解物质的溶剂名称（可选）
+string volume                   # 溶剂的体积（如 "10 mL"，可选）
+string amount                   # 要溶解物质的量描述（可选）
+string temp                     # 溶解时的温度（如 "60 °C", "room temperature"，可选）
+string time                     # 溶解的时间（如 "30 min", "1 h"，可选）
+float64 stir_speed              # 搅拌速度（可选，默认300 RPM）
+string mass                     # 物质质量（如 "2.9 g"，可选）
+string mol                      # 物质摩尔数（如 "0.12 mol"，可选）
+string reagent                  # 试剂名称（可选）
+string event                    # 事件标识（如 'A', 'B'，可选）
 ---
+# Result - 操作结果
 bool success                    # 操作是否成功
 string message                  # 结果消息
 string return_info
 ---
+# Feedback - 实时反馈
 string status                   # 当前状态描述
 float64 progress               # 进度百分比 (0-100)

unilabos_msgs/action/EvacuateAndRefill.action

@@ -1,7 +1,6 @@
-# Organic
+# Organic Synthesis Station EvacuateAndRefill Action
 string vessel
 string gas
-int32 repeats
 ---
 string return_info
 bool success

unilabos_msgs/action/Evaporate.action

@@ -1,9 +1,10 @@
-# Organic
-string vessel
-float64 pressure
-float64 temp
-float64 time
-float64 stir_speed
+# Organic Synthesis Station Evaporate Action
+string vessel                    # 目标容器
+float64 pressure                 # 真空度
+float64 temp                     # 温度
+string time                      # 🔧 蒸发时间（支持带单位，如"3 min","180"，默认秒）
+float64 stir_speed              # 旋转速度
+string solvent                   # 溶剂名称
 ---
 string return_info
 bool success

unilabos_msgs/action/Filter.action

@@ -1,11 +1,11 @@
 # Goal - 过滤操作的目标参数  
-string vessel                    # 过滤容器  
-string filtrate_vessel          # 滤液容器 (可选)  
-bool stir                        # 是否搅拌  
-float64 stir_speed              # 搅拌速度 (可选)  
-float64 temp                     # 温度 (可选，摄氏度)  
-bool continue_heatchill          # 是否继续加热冷却  
-float64 volume                   # 过滤体积 (可选)  
+string vessel                    # 过滤容器（必需）
+string filtrate_vessel          # 滤液容器（可选）
+bool stir                        # 是否搅拌（默认false）
+float64 stir_speed              # 搅拌速度（默认0.0）
+float64 temp                     # 温度（默认25.0）
+bool continue_heatchill          # 是否继续加热冷却（默认false）
+float64 volume                   # 过滤体积（默认0.0）
 ---
 # Result - 操作结果  
 bool success                     # 操作是否成功  

unilabos_msgs/action/HeatChill.action

@@ -1,12 +1,19 @@
-# Organic
-string vessel
-float64 temp
-float64 time
-bool stir
-float64 stir_speed
-string purpose
+# Goal - 加热冷却操作的目标参数
+string vessel                    # 加热容器名称（必需）
+float64 temp                     # 目标温度（可选，默认25.0）
+string time                      # 🔧 加热时间（支持带单位，如"5 min","300"，默认秒）
+string temp_spec                 # 温度规格（可选）
+string time_spec                 # 时间规格（可选）
+string pressure                  # 压力规格（可选，不做特殊处理）
+string reflux_solvent           # 回流溶剂名称（可选，不做特殊处理）
+bool stir                        # 是否搅拌（可选，默认false）
+float64 stir_speed              # 搅拌速度（可选，默认300.0）
+string purpose                   # 操作目的（可选）
 ---
+# Result - 操作结果
+bool success                     # 操作是否成功
+string message                   # 结果消息
 string return_info
-bool success
 ---
-string status
+# Feedback - 实时反馈
+string status                    # 当前状态描述

unilabos_msgs/action/PumpTransfer.action

@@ -9,6 +9,11 @@ string rinsing_solvent
 float64 rinsing_volume
 int32 rinsing_repeats
 bool solid
+float64 flowrate
+float64 transfer_flowrate
+string rate_spec
+string event
+string through
 ---
 string return_info
 bool success

unilabos_msgs/action/Recrystallize.action

@@ -1,9 +1,9 @@
 # Request
-string ratio
-string solvent1
-string solvent2
-string vessel
-float64 volume
+string ratio                     # 溶剂比例（如"1:1","3:7"）
+string solvent1                  # 第一种溶剂
+string solvent2                  # 第二种溶剂
+string vessel                    # 目标容器
+string volume                    # 🔧 总体积（支持带单位，如"100 mL","50"，默认mL）
 ---
 # Result
 bool success

unilabos_msgs/action/RunColumn.action

@@ -1,10 +1,19 @@
-string from_vessel              # 源容器的名称，即样品起始所在的容器
-string to_vessel                # 目标容器的名称，分离后的样品要到达的容器
-string column                   # 所使用的柱子的名称
+# Goal - 柱层析操作的目标参数
+string from_vessel              # 源容器的名称，即样品起始所在的容器（必需）
+string to_vessel                # 目标容器的名称，分离后的样品要到达的容器（必需）
+string column                   # 所使用的柱子的名称（必需）
+string rf                       # Rf值（可选）
+string pct1                     # 第一种溶剂百分比（如 "40 %"，可选）
+string pct2                     # 第二种溶剂百分比（如 "50 %"，可选）
+string solvent1                 # 第一种溶剂名称（可选）
+string solvent2                 # 第二种溶剂名称（可选）
+string ratio                    # 溶剂比例（如 "5:95"，可选）
 ---
+# Result - 操作结果
 bool success                    # 操作是否成功
 string message                  # 结果消息
 string return_info
 ---
+# Feedback - 实时反馈
 string status                   # 当前状态描述
 float64 progress               # 进度百分比 (0-100)

unilabos_msgs/action/Separate.action

@@ -1,22 +1,27 @@
-# Organic
-string purpose  # 'wash' or 'extract'. 'wash' means that product phase will not be the added solvent phase, 'extract' means product phase will be the added solvent phase. If no solvent is added just use 'extract'.
-string product_phase # 'top' or 'bottom'. Phase that product will be in.
-string from_vessel #Contents of from_vessel are transferred to separation_vessel and separation is performed.
-string separation_vessel # Vessel in which separation of phases will be carried out.
-string to_vessel # Vessel to send product phase to.
-string waste_phase_to_vessel # Optional. Vessel to send waste phase to.
-string solvent # Optional. Solvent to add to separation vessel after contents of from_vessel has been transferred to create two phases.
-float64 solvent_volume # Optional. Volume of solvent to add.
-string through # Optional. Solid chemical to send product phase through on way to to_vessel, e.g. 'celite'.
-int32 repeats # Optional. Number of separations to perform.
-float64 stir_time # Optional. Time stir for after adding solvent, before separation of phases.
-float64 stir_speed # Optional. Speed to stir at after adding solvent, before separation of phases.
-float64 settling_time # Optional. Time
+# Goal - 分离操作的目标参数
+string vessel                   # 分离容器名称（XDL参数，必需）
+string purpose                  # 分离目的 ('wash', 'extract', 'separate'，可选）
+string product_phase            # 产物相 ('top', 'bottom'，可选）
+string from_vessel              # 源容器（可选）
+string separation_vessel        # 分离容器（与vessel同义，可选）
+string to_vessel                # 目标容器（可选）
+string waste_phase_to_vessel    # 废相目标容器（可选）
+string product_vessel           # 产物收集容器（XDL参数，可选）
+string waste_vessel             # 废液收集容器（XDL参数，可选）
+string solvent                  # 溶剂名称（可选）
+string solvent_volume           # 溶剂体积（如 "200 mL"，可选）
+string volume                   # 体积规格（XDL参数，如 "?"，可选）
+string through                  # 通过材料（如 'celite'，可选）
+int32 repeats                   # 重复次数（可选，默认1）
+float64 stir_time               # 搅拌时间（可选，默认30秒）
+float64 stir_speed              # 搅拌速度（可选，默认300 RPM）
+float64 settling_time           # 沉降时间（可选，默认300秒）
 ---
+# Result - 操作结果
+bool success                     # 操作是否成功
+string message                   # 结果消息
 string return_info
-bool success
 ---
-string status
-string current_device
-builtin_interfaces/Duration time_spent
-builtin_interfaces/Duration time_remaining
+# Feedback - 实时反馈
+string status                    # 当前状态描述
+float64 progress                # 进度百分比 (0-100)

unilabos_msgs/action/Stir.action

@@ -1,9 +1,16 @@
-# Organic
-float64 stir_time
-float64 stir_speed
-float64 settling_time
+# Goal - 搅拌操作的目标参数
+string vessel                    # 搅拌容器名称（必需）
+string time                      # 🔧 搅拌时间（如 "0.5 h", "30 min", "300"，默认秒）
+string event                     # 事件标识（如 "A", "B"）
+string time_spec                 # 时间规格（如 "several minutes"）
+float64 stir_time               # 解析后的搅拌时间（秒）
+float64 stir_speed              # 搅拌速度（默认200.0）
+string settling_time            # 🔧 沉降时间（支持带单位，默认秒）
 ---
+# Result - 操作结果
+bool success                     # 操作是否成功
+string message                   # 结果消息
 string return_info
-bool success
 ---
-string status
+# Feedback - 实时反馈
+string status                    # 当前状态描述

unilabos_msgs/action/WashSolid.action

@@ -1,16 +1,23 @@
-string vessel                   # 装有固体物质的容器名称
-string solvent                  # 用于清洗固体的溶剂名称
-float64 volume                  # 清洗溶剂的体积
-string filtrate_vessel          # 滤液要收集到的容器名称，可选参数
-float64 temp                    # 清洗时的温度，可选参数
-bool stir                       # 是否在清洗过程中搅拌，默认为 False
-float64 stir_speed              # 搅拌速度，可选参数
-float64 time                    # 清洗的时间，可选参数
-int32 repeats                   # 清洗操作的重复次数，默认为 1
+# Goal - 固体清洗操作的目标参数
+string vessel                    # 装有固体的容器名称（必需）
+string solvent                   # 清洗溶剂名称（必需）
+string volume                    # 🔧 体积（支持数字和带单位的字符串，如"100 mL","?"）
+string filtrate_vessel          # 滤液收集容器（可选，默认""）
+float64 temp                     # 清洗温度（可选，默认25.0）
+bool stir                        # 是否搅拌（可选，默认false）
+float64 stir_speed              # 搅拌速度（可选，默认0.0）
+string time                      # 🔧 清洗时间（支持带单位，如"5 min","300 s"，默认秒）
+int32 repeats                    # 重复次数（与repeats_spec二选一）
+string volume_spec               # 体积规格（优先级高于volume）
+string repeats_spec             # 重复次数规格（优先级高于repeats）
+string mass                     # 固体质量描述（可选）
+string event                    # 事件标识符（可选）
 ---
-bool success                    # 操作是否成功
-string message                  # 结果消息
+# Result - 操作结果
+bool success                     # 操作是否成功
+string message                   # 结果消息
 string return_info
 ---
-string status                   # 当前状态描述
-float64 progress               # 进度百分比 (0-100)
+# Feedback - 实时反馈
+string status                    # 当前状态描述
+float64 progress                 # 进度百分比 (0-100)