使用16个孔与固定tip头类型，来定位slot位置

新增 tip_above_rack_length 参数并更新枪头尺寸

.conda/base/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos
-  version: 0.11.1
+  version: 0.10.19
 
 source:
   path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
   - pymodbus
   - matplotlib
   - pylibftdi
-  - uni-lab::unilabos-env ==0.11.1
+  - uni-lab::unilabos-env ==0.10.19
 
 about:
   repository: https://github.com/deepmodeling/Uni-Lab-OS

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.11.1
+  version: 0.10.19
 
 build:
   noarch: generic

.conda/full/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos-full
-  version: 0.11.1
+  version: 0.10.19
 
 build:
   noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
   run:
   # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.11.1
+  - uni-lab::unilabos ==0.10.19
   # Documentation tools
   - sphinx
   - sphinx_rtd_theme

.conda/scripts/post-link.bat

@@ -0,0 +1,9 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM upgrade pip
+"%PREFIX%\python.exe" -m pip install --upgrade pip
+
+REM install extra deps
+"%PREFIX%\python.exe" -m pip install paho-mqtt opentrons_shared_data
+"%PREFIX%\python.exe" -m pip install git+https://github.com/Xuwznln/pylabrobot.git

.conda/scripts/post-link.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euxo pipefail
+
+# make sure pip is available
+"$PREFIX/bin/python" -m pip install --upgrade pip
+
+# install extra deps
+"$PREFIX/bin/python" -m pip install paho-mqtt opentrons_shared_data
+"$PREFIX/bin/python" -m pip install git+https://github.com/Xuwznln/pylabrobot.git

.cursor/rules/device-drivers.mdc

@@ -1,328 +0,0 @@
----
-description: 设备驱动开发规范
-globs: ["unilabos/devices/**/*.py"]
----
-
-# 设备驱动开发规范
-
-## 目录结构
-
-```
-unilabos/devices/
-├── virtual/           # 虚拟设备（用于测试）
-│   ├── virtual_stirrer.py
-│   └── virtual_centrifuge.py
-├── liquid_handling/   # 液体处理设备
-├── balance/           # 天平设备
-├── hplc/              # HPLC设备
-├── pump_and_valve/    # 泵和阀门
-├── temperature/       # 温度控制设备
-├── workstation/       # 工作站（组合设备）
-└── ...
-```
-
-## 设备类完整模板
-
-```python
-import asyncio
-import logging
-import time as time_module
-from typing import Dict, Any, Optional
-
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-
-
-class MyDevice:
-    """
-    设备类描述
-
-    Attributes:
-        device_id: 设备唯一标识
-        config: 设备配置字典
-        data: 设备状态数据
-    """
-
-    _ros_node: BaseROS2DeviceNode
-
-    def __init__(
-        self,
-        device_id: str = None,
-        config: Dict[str, Any] = None,
-        **kwargs
-    ):
-        """
-        初始化设备
-
-        Args:
-            device_id: 设备ID
-            config: 配置字典
-            **kwargs: 其他参数
-        """
-        # 兼容不同调用方式
-        if device_id is None and 'id' in kwargs:
-            device_id = kwargs.pop('id')
-        if config is None and 'config' in kwargs:
-            config = kwargs.pop('config')
-
-        self.device_id = device_id or "unknown_device"
-        self.config = config or {}
-        self.data = {}
-
-        # 从config读取参数
-        self.port = self.config.get('port') or kwargs.get('port', 'COM1')
-        self._max_value = self.config.get('max_value', 1000.0)
-
-        # 初始化日志
-        self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
-
-        self.logger.info(f"设备 {self.device_id} 已创建")
-
-    def post_init(self, ros_node: BaseROS2DeviceNode):
-        """
-        ROS节点注入 - 在ROS节点创建后调用
-
-        Args:
-            ros_node: ROS2设备节点实例
-        """
-        self._ros_node = ros_node
-
-    async def initialize(self) -> bool:
-        """
-        初始化设备 - 连接硬件、设置初始状态
-
-        Returns:
-            bool: 初始化是否成功
-        """
-        self.logger.info(f"初始化设备 {self.device_id}")
-
-        try:
-            # 执行硬件初始化
-            # await self._connect_hardware()
-
-            # 设置初始状态
-            self.data.update({
-                "status": "待机",
-                "is_running": False,
-                "current_value": 0.0,
-            })
-
-            self.logger.info(f"设备 {self.device_id} 初始化完成")
-            return True
-
-        except Exception as e:
-            self.logger.error(f"初始化失败: {e}")
-            self.data["status"] = f"错误: {e}"
-            return False
-
-    async def cleanup(self) -> bool:
-        """
-        清理设备 - 断开连接、释放资源
-
-        Returns:
-            bool: 清理是否成功
-        """
-        self.logger.info(f"清理设备 {self.device_id}")
-
-        self.data.update({
-            "status": "离线",
-            "is_running": False,
-        })
-
-        return True
-
-    # ==================== 设备动作 ====================
-
-    async def execute_action(
-        self,
-        param1: float,
-        param2: str = "",
-        **kwargs
-    ) -> bool:
-        """
-        执行设备动作
-
-        Args:
-            param1: 参数1
-            param2: 参数2（可选）
-
-        Returns:
-            bool: 动作是否成功
-        """
-        # 类型转换和验证
-        try:
-            param1 = float(param1)
-        except (ValueError, TypeError) as e:
-            self.logger.error(f"参数类型错误: {e}")
-            return False
-
-        # 参数验证
-        if param1 > self._max_value:
-            self.logger.error(f"参数超出范围: {param1} > {self._max_value}")
-            return False
-
-        self.logger.info(f"执行动作: param1={param1}, param2={param2}")
-
-        # 更新状态
-        self.data.update({
-            "status": "运行中",
-            "is_running": True,
-        })
-
-        # 执行动作（带进度反馈）
-        duration = 10.0  # 秒
-        start_time = time_module.time()
-
-        while True:
-            elapsed = time_module.time() - start_time
-            remaining = max(0, duration - elapsed)
-            progress = min(100, (elapsed / duration) * 100)
-
-            self.data.update({
-                "status": f"运行中: {progress:.0f}%",
-                "remaining_time": remaining,
-            })
-
-            if remaining <= 0:
-                break
-
-            await self._ros_node.sleep(1.0)
-
-        # 完成
-        self.data.update({
-            "status": "完成",
-            "is_running": False,
-        })
-
-        self.logger.info("动作执行完成")
-        return True
-
-    # ==================== 状态属性 ====================
-
-    @property
-    def status(self) -> str:
-        """设备状态 - 自动发布为ROS Topic"""
-        return self.data.get("status", "未知")
-
-    @property
-    def is_running(self) -> bool:
-        """是否正在运行"""
-        return self.data.get("is_running", False)
-
-    @property
-    def current_value(self) -> float:
-        """当前值"""
-        return self.data.get("current_value", 0.0)
-
-    # ==================== 辅助方法 ====================
-
-    def get_device_info(self) -> Dict[str, Any]:
-        """获取设备信息"""
-        return {
-            "device_id": self.device_id,
-            "status": self.status,
-            "is_running": self.is_running,
-            "current_value": self.current_value,
-        }
-
-    def __str__(self) -> str:
-        return f"MyDevice({self.device_id}: {self.status})"
-```
-
-## 关键规则
-
-### 1. 参数处理
-
-所有动作方法的参数都可能以字符串形式传入，必须进行类型转换：
-
-```python
-async def my_action(self, value: float, **kwargs) -> bool:
-    # 始终进行类型转换
-    try:
-        value = float(value)
-    except (ValueError, TypeError) as e:
-        self.logger.error(f"参数类型错误: {e}")
-        return False
-```
-
-### 2. vessel 参数处理
-
-vessel 参数可能是字符串ID或字典：
-
-```python
-def extract_vessel_id(vessel: Union[str, dict]) -> str:
-    if isinstance(vessel, dict):
-        return vessel.get("id", "")
-    return str(vessel) if vessel else ""
-```
-
-### 3. 状态更新
-
-使用 `self.data` 字典存储状态，属性读取状态：
-
-```python
-# 更新状态
-self.data["status"] = "运行中"
-self.data["current_speed"] = 300.0
-
-# 读取状态（通过属性）
-@property
-def status(self) -> str:
-    return self.data.get("status", "待机")
-```
-
-### 4. 异步等待
-
-使用 ROS 节点的 sleep 方法：
-
-```python
-# 正确
-await self._ros_node.sleep(1.0)
-
-# 避免（除非在纯 Python 测试环境）
-await asyncio.sleep(1.0)
-```
-
-### 5. 进度反馈
-
-长时间运行的操作需要提供进度反馈：
-
-```python
-while remaining > 0:
-    progress = (elapsed / total_time) * 100
-    self.data["status"] = f"运行中: {progress:.0f}%"
-    self.data["remaining_time"] = remaining
-
-    await self._ros_node.sleep(1.0)
-```
-
-## 虚拟设备
-
-虚拟设备用于测试和演示，放在 `unilabos/devices/virtual/` 目录：
-
-- 类名以 `Virtual` 开头
-- 文件名以 `virtual_` 开头
-- 模拟真实设备的行为和时序
-- 使用表情符号增强日志可读性（可选）
-
-## 工作站设备
-
-工作站是组合多个设备的复杂设备：
-
-```python
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-
-class MyWorkstation(WorkstationBase):
-    """组合工作站"""
-
-    async def execute_workflow(self, workflow: Dict[str, Any]) -> bool:
-        """执行工作流"""
-        pass
-```
-
-## 设备注册
-
-设备类开发完成后，需要在注册表中注册：
-
-1. 创建/编辑 `unilabos/registry/devices/my_category.yaml`
-2. 添加设备配置（参考 `virtual_device.yaml`）
-3. 运行 `--complete_registry` 自动生成 schema

.cursor/rules/protocol-development.mdc

@@ -1,240 +0,0 @@
----
-description: 协议编译器开发规范
-globs: ["unilabos/compile/**/*.py"]
----
-
-# 协议编译器开发规范
-
-## 概述
-
-协议编译器负责将高级实验操作（如 Stir、Add、Filter）编译为设备可执行的动作序列。
-
-## 文件命名
-
-- 位置: `unilabos/compile/`
-- 命名: `{operation}_protocol.py`
-- 示例: `stir_protocol.py`, `add_protocol.py`, `filter_protocol.py`
-
-## 协议函数模板
-
-```python
-from typing import List, Dict, Any, Union
-import networkx as nx
-import logging
-
-from .utils.unit_parser import parse_time_input
-from .utils.vessel_parser import extract_vessel_id
-
-logger = logging.getLogger(__name__)
-
-
-def generate_{operation}_protocol(
-    G: nx.DiGraph,
-    vessel: Union[str, dict],
-    param1: Union[str, float] = "0",
-    param2: float = 0.0,
-    **kwargs
-) -> List[Dict[str, Any]]:
-    """
-    生成{操作}协议序列
-
-    Args:
-        G: 物理拓扑图 (NetworkX DiGraph)
-        vessel: 容器ID或Resource字典
-        param1: 参数1（支持字符串单位，如 "5 min"）
-        param2: 参数2
-        **kwargs: 其他参数
-
-    Returns:
-        List[Dict]: 动作序列
-
-    Raises:
-        ValueError: 参数无效时
-    """
-    # 1. 提取 vessel_id
-    vessel_id = extract_vessel_id(vessel)
-
-    # 2. 验证参数
-    if not vessel_id:
-        raise ValueError("vessel 参数不能为空")
-
-    if vessel_id not in G.nodes():
-        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
-
-    # 3. 解析参数（支持单位）
-    parsed_param1 = parse_time_input(param1)  # "5 min" -> 300.0
-
-    # 4. 查找设备
-    device_id = find_connected_device(G, vessel_id, device_type="my_device")
-
-    # 5. 生成动作序列
-    action_sequence = []
-
-    action = {
-        "device_id": device_id,
-        "action_name": "my_action",
-        "action_kwargs": {
-            "vessel": {"id": vessel_id},  # 始终使用字典格式
-            "param1": float(parsed_param1),
-            "param2": float(param2),
-        }
-    }
-    action_sequence.append(action)
-
-    logger.info(f"生成协议: {len(action_sequence)} 个动作")
-    return action_sequence
-
-
-def find_connected_device(
-    G: nx.DiGraph,
-    vessel_id: str,
-    device_type: str = ""
-) -> str:
-    """
-    查找与容器相连的设备
-
-    Args:
-        G: 拓扑图
-        vessel_id: 容器ID
-        device_type: 设备类型关键字
-
-    Returns:
-        str: 设备ID
-    """
-    # 查找所有匹配类型的设备
-    device_nodes = []
-    for node in G.nodes():
-        node_class = G.nodes[node].get('class', '') or ''
-        if device_type.lower() in node_class.lower():
-            device_nodes.append(node)
-
-    # 检查连接
-    if vessel_id and device_nodes:
-        for device in device_nodes:
-            if G.has_edge(device, vessel_id) or G.has_edge(vessel_id, device):
-                return device
-
-    # 返回第一个可用设备
-    if device_nodes:
-        return device_nodes[0]
-
-    # 默认设备
-    return f"{device_type}_1"
-```
-
-## 关键规则
-
-### 1. vessel 参数处理
-
-vessel 参数可能是字符串或字典，需要统一处理：
-
-```python
-def extract_vessel_id(vessel: Union[str, dict]) -> str:
-    """提取vessel_id"""
-    if isinstance(vessel, dict):
-        # 可能是 {"id": "xxx"} 或完整 Resource 对象
-        return vessel.get("id", list(vessel.values())[0].get("id", ""))
-    return str(vessel) if vessel else ""
-```
-
-### 2. action_kwargs 中的 vessel
-
-始终使用 `{"id": vessel_id}` 格式传递 vessel：
-
-```python
-# 正确
-"action_kwargs": {
-    "vessel": {"id": vessel_id},  # 字符串ID包装为字典
-}
-
-# 避免
-"action_kwargs": {
-    "vessel": vessel_resource,  # 不要传递完整 Resource 对象
-}
-```
-
-### 3. 单位解析
-
-使用 `parse_time_input` 解析时间参数：
-
-```python
-from .utils.unit_parser import parse_time_input
-
-# 支持格式: "5 min", "1 h", "300", "1.5 hours"
-time_seconds = parse_time_input("5 min")  # -> 300.0
-time_seconds = parse_time_input(120)      # -> 120.0
-time_seconds = parse_time_input("1 h")    # -> 3600.0
-```
-
-### 4. 参数验证
-
-所有参数必须进行验证和类型转换：
-
-```python
-# 验证范围
-if speed < 10.0 or speed > 1500.0:
-    logger.warning(f"速度 {speed} 超出范围，修正为 300")
-    speed = 300.0
-
-# 类型转换
-param = float(param) if not isinstance(param, (int, float)) else param
-```
-
-### 5. 日志记录
-
-使用项目日志记录器：
-
-```python
-logger = logging.getLogger(__name__)
-
-def generate_protocol(...):
-    logger.info(f"开始生成协议...")
-    logger.debug(f"参数: vessel={vessel_id}, time={time}")
-    logger.warning(f"参数修正: {old_value} -> {new_value}")
-```
-
-## 便捷函数
-
-为常用操作提供便捷函数：
-
-```python
-def stir_briefly(G: nx.DiGraph, vessel: Union[str, dict],
-                speed: float = 300.0) -> List[Dict[str, Any]]:
-    """短时间搅拌（30秒）"""
-    return generate_stir_protocol(G, vessel, time="30", stir_speed=speed)
-
-def stir_vigorously(G: nx.DiGraph, vessel: Union[str, dict],
-                   time: str = "5 min") -> List[Dict[str, Any]]:
-    """剧烈搅拌"""
-    return generate_stir_protocol(G, vessel, time=time, stir_speed=800.0)
-```
-
-## 测试函数
-
-每个协议文件应包含测试函数：
-
-```python
-def test_{operation}_protocol():
-    """测试协议生成"""
-    # 测试参数处理
-    vessel_dict = {"id": "flask_1", "name": "反应瓶1"}
-    vessel_id = extract_vessel_id(vessel_dict)
-    assert vessel_id == "flask_1"
-
-    # 测试单位解析
-    time_s = parse_time_input("5 min")
-    assert time_s == 300.0
-
-
-if __name__ == "__main__":
-    test_{operation}_protocol()
-```
-
-## 现有协议参考
-
-- `stir_protocol.py` - 搅拌操作
-- `add_protocol.py` - 添加物料
-- `filter_protocol.py` - 过滤操作
-- `heatchill_protocol.py` - 加热/冷却
-- `separate_protocol.py` - 分离操作
-- `evaporate_protocol.py` - 蒸发操作

.cursor/rules/registry-config.mdc

@@ -1,319 +0,0 @@
----
-description: 注册表配置规范 (YAML)
-globs: ["unilabos/registry/**/*.yaml"]
----
-
-# 注册表配置规范
-
-## 概述
-
-注册表使用 YAML 格式定义设备和资源类型，是 Uni-Lab-OS 的核心配置系统。
-
-## 目录结构
-
-```
-unilabos/registry/
-├── devices/              # 设备类型注册
-│   ├── virtual_device.yaml
-│   ├── liquid_handler.yaml
-│   └── ...
-├── device_comms/         # 通信设备配置
-│   ├── communication_devices.yaml
-│   └── modbus_ioboard.yaml
-└── resources/            # 资源类型注册
-    ├── bioyond/
-    ├── organic/
-    ├── opentrons/
-    └── ...
-```
-
-## 设备注册表格式
-
-### 基本结构
-
-```yaml
-device_type_id:
-  # 基本信息
-  description: "设备描述"
-  version: "1.0.0"
-  category:
-    - category_name
-  icon: "icon_device.webp"
-
-  # 类配置
-  class:
-    module: "unilabos.devices.my_module:MyClass"
-    type: python
-
-    # 状态类型（属性 -> ROS消息类型）
-    status_types:
-      status: String
-      temperature: Float64
-      is_running: Bool
-
-    # 动作映射
-    action_value_mappings:
-      action_name:
-        type: UniLabJsonCommand  # 或 UniLabJsonCommandAsync
-        goal: {}
-        feedback: {}
-        result: {}
-        schema: {...}
-        handles: {}
-```
-
-### action_value_mappings 详细格式
-
-```yaml
-action_value_mappings:
-  # 同步动作
-  my_sync_action:
-    type: UniLabJsonCommand
-    goal:
-      param1: param1
-      param2: param2
-    feedback: {}
-    result:
-      success: success
-      message: message
-    goal_default:
-      param1: 0.0
-      param2: ""
-    handles: {}
-    placeholder_keys:
-      device_param: unilabos_devices   # 设备选择器
-      resource_param: unilabos_resources  # 资源选择器
-    schema:
-      title: "动作名称参数"
-      description: "动作描述"
-      type: object
-      properties:
-        goal:
-          type: object
-          properties:
-            param1:
-              type: number
-            param2:
-              type: string
-          required:
-            - param1
-        feedback: {}
-        result:
-          type: object
-          properties:
-            success:
-              type: boolean
-            message:
-              type: string
-      required:
-        - goal
-
-  # 异步动作
-  my_async_action:
-    type: UniLabJsonCommandAsync
-    goal: {}
-    feedback:
-      progress: progress
-      current_status: status
-    result:
-      success: success
-    schema: {...}
-```
-
-### 自动生成的动作
-
-以 `auto-` 开头的动作由系统自动生成：
-
-```yaml
-action_value_mappings:
-  auto-initialize:
-    type: UniLabJsonCommandAsync
-    goal: {}
-    feedback: {}
-    result: {}
-    schema: {...}
-
-  auto-cleanup:
-    type: UniLabJsonCommandAsync
-    goal: {}
-    feedback: {}
-    result: {}
-    schema: {...}
-```
-
-### handles 配置
-
-用于工作流编辑器中的数据流连接：
-
-```yaml
-handles:
-  input:
-    - handler_key: "input_resource"
-      data_type: "resource"
-      label: "输入资源"
-      data_source: "handle"
-      data_key: "resources"
-  output:
-    - handler_key: "output_labware"
-      data_type: "resource"
-      label: "输出器皿"
-      data_source: "executor"
-      data_key: "created_resource.@flatten"
-```
-
-## 资源注册表格式
-
-```yaml
-resource_type_id:
-  description: "资源描述"
-  version: "1.0.0"
-  category:
-    - category_name
-  icon: ""
-  handles: []
-  init_param_schema: {}
-
-  class:
-    module: "unilabos.resources.my_module:MyResource"
-    type: pylabrobot  # 或 python
-```
-
-### PyLabRobot 资源示例
-
-```yaml
-BIOYOND_Electrolyte_6VialCarrier:
-  category:
-    - bottle_carriers
-    - bioyond
-  class:
-    module: "unilabos.resources.bioyond.bottle_carriers:BIOYOND_Electrolyte_6VialCarrier"
-    type: pylabrobot
-  version: "1.0.0"
-```
-
-## 状态类型映射
-
-Python 类型到 ROS 消息类型的映射：
-
-| Python 类型 | ROS 消息类型 |
-|------------|-------------|
-| `str` | `String` |
-| `bool` | `Bool` |
-| `int` | `Int64` |
-| `float` | `Float64` |
-| `list` | `String` (序列化) |
-| `dict` | `String` (序列化) |
-
-## 自动完善注册表
-
-使用 `--complete_registry` 参数自动生成 schema：
-
-```bash
-python -m unilabos.app.main --complete_registry
-```
-
-这会：
-1. 扫描设备类的方法签名
-2. 自动生成 `auto-` 前缀的动作
-3. 生成 JSON Schema
-4. 更新 YAML 文件
-
-## 验证规则
-
-1. **device_type_id** 必须唯一
-2. **module** 路径必须正确可导入
-3. **status_types** 的类型必须是有效的 ROS 消息类型
-4. **schema** 必须是有效的 JSON Schema
-
-## 示例：完整设备配置
-
-```yaml
-virtual_stirrer:
-  category:
-    - virtual_device
-  description: "虚拟搅拌器设备"
-  version: "1.0.0"
-  icon: "icon_stirrer.webp"
-  handles: []
-  init_param_schema: {}
-
-  class:
-    module: "unilabos.devices.virtual.virtual_stirrer:VirtualStirrer"
-    type: python
-
-    status_types:
-      status: String
-      operation_mode: String
-      current_speed: Float64
-      is_stirring: Bool
-      remaining_time: Float64
-
-    action_value_mappings:
-      auto-initialize:
-        type: UniLabJsonCommandAsync
-        goal: {}
-        feedback: {}
-        result: {}
-        schema:
-          title: "initialize参数"
-          type: object
-          properties:
-            goal:
-              type: object
-              properties: {}
-            feedback: {}
-            result: {}
-          required:
-            - goal
-
-      stir:
-        type: UniLabJsonCommandAsync
-        goal:
-          stir_time: stir_time
-          stir_speed: stir_speed
-          settling_time: settling_time
-        feedback:
-          current_speed: current_speed
-          remaining_time: remaining_time
-        result:
-          success: success
-        goal_default:
-          stir_time: 60.0
-          stir_speed: 300.0
-          settling_time: 30.0
-        handles: {}
-        schema:
-          title: "stir参数"
-          description: "搅拌操作"
-          type: object
-          properties:
-            goal:
-              type: object
-              properties:
-                stir_time:
-                  type: number
-                  description: "搅拌时间（秒）"
-                stir_speed:
-                  type: number
-                  description: "搅拌速度（RPM）"
-                settling_time:
-                  type: number
-                  description: "沉降时间（秒）"
-              required:
-                - stir_time
-                - stir_speed
-            feedback:
-              type: object
-              properties:
-                current_speed:
-                  type: number
-                remaining_time:
-                  type: number
-            result:
-              type: object
-              properties:
-                success:
-                  type: boolean
-          required:
-            - goal
-```

.cursor/rules/ros-integration.mdc

@@ -1,233 +0,0 @@
----
-description: ROS 2 集成开发规范
-globs: ["unilabos/ros/**/*.py", "**/*_node.py"]
----
-
-# ROS 2 集成开发规范
-
-## 概述
-
-Uni-Lab-OS 使用 ROS 2 作为设备通信中间件，基于 rclpy 实现。
-
-## 核心组件
-
-### BaseROS2DeviceNode
-
-设备节点基类，提供：
-- ROS Topic 自动发布（状态属性）
-- Action Server 自动创建（设备动作）
-- 资源管理服务
-- 异步任务调度
-
-```python
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-```
-
-### 消息转换器
-
-```python
-from unilabos.ros.msgs.message_converter import (
-    convert_to_ros_msg,
-    convert_from_ros_msg_with_mapping,
-    msg_converter_manager,
-    ros_action_to_json_schema,
-    ros_message_to_json_schema,
-)
-```
-
-## 设备与 ROS 集成
-
-### post_init 方法
-
-设备类必须实现 `post_init` 方法接收 ROS 节点：
-
-```python
-class MyDevice:
-    _ros_node: BaseROS2DeviceNode
-
-    def post_init(self, ros_node: BaseROS2DeviceNode):
-        """ROS节点注入"""
-        self._ros_node = ros_node
-```
-
-### 状态属性发布
-
-设备的 `@property` 属性会自动发布为 ROS Topic：
-
-```python
-class MyDevice:
-    @property
-    def temperature(self) -> float:
-        return self._temperature
-
-    # 自动发布到 /{namespace}/temperature Topic
-```
-
-### Topic 配置装饰器
-
-```python
-from unilabos.utils.decorator import topic_config
-
-class MyDevice:
-    @property
-    @topic_config(period=1.0, print_publish=False, qos=10)
-    def fast_data(self) -> float:
-        """高频数据 - 每秒发布一次"""
-        return self._fast_data
-
-    @property
-    @topic_config(period=5.0)
-    def slow_data(self) -> str:
-        """低频数据 - 每5秒发布一次"""
-        return self._slow_data
-```
-
-### 订阅装饰器
-
-```python
-from unilabos.utils.decorator import subscribe
-
-class MyDevice:
-    @subscribe(topic="/external/sensor_data", qos=10)
-    def on_sensor_data(self, msg):
-        """订阅外部Topic"""
-        self._sensor_value = msg.data
-```
-
-## 异步操作
-
-### 使用 ROS 节点睡眠
-
-```python
-# 推荐：使用ROS节点的睡眠方法
-await self._ros_node.sleep(1.0)
-
-# 不推荐：直接使用asyncio（可能导致回调阻塞）
-await asyncio.sleep(1.0)
-```
-
-### 获取事件循环
-
-```python
-from unilabos.ros.x.rclpyx import get_event_loop
-
-loop = get_event_loop()
-```
-
-## 消息类型
-
-### unilabos_msgs 包
-
-```python
-from unilabos_msgs.msg import Resource
-from unilabos_msgs.srv import (
-    ResourceAdd,
-    ResourceDelete,
-    ResourceUpdate,
-    ResourceList,
-    SerialCommand,
-)
-from unilabos_msgs.action import SendCmd
-```
-
-### Resource 消息结构
-
-```python
-Resource:
-    id: str
-    name: str
-    category: str
-    type: str
-    parent: str
-    children: List[str]
-    config: str  # JSON字符串
-    data: str    # JSON字符串
-    sample_id: str
-    pose: Pose
-```
-
-## 日志适配器
-
-```python
-from unilabos.utils.log import info, debug, warning, error, trace
-
-class MyDevice:
-    def __init__(self):
-        # 创建设备专属日志器
-        self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
-```
-
-ROSLoggerAdapter 同时向自定义日志和 ROS 日志发送消息。
-
-## Action Server
-
-设备动作自动创建为 ROS Action Server：
-
-```yaml
-# 在注册表中配置
-action_value_mappings:
-  my_action:
-    type: UniLabJsonCommandAsync  # 异步Action
-    goal: {...}
-    feedback: {...}
-    result: {...}
-```
-
-### Action 类型
-
-- **UniLabJsonCommand**: 同步动作
-- **UniLabJsonCommandAsync**: 异步动作（支持feedback）
-
-## 服务客户端
-
-```python
-from rclpy.client import Client
-
-# 调用其他节点的服务
-response = await self._ros_node.call_service(
-    service_name="/other_node/service",
-    request=MyServiceRequest(...)
-)
-```
-
-## 命名空间
-
-设备节点使用命名空间隔离：
-
-```
-/{device_id}/                 # 设备命名空间
-/{device_id}/status          # 状态Topic
-/{device_id}/temperature     # 温度Topic
-/{device_id}/my_action       # 动作Server
-```
-
-## 调试
-
-### 查看 Topic
-
-```bash
-ros2 topic list
-ros2 topic echo /{device_id}/status
-```
-
-### 查看 Action
-
-```bash
-ros2 action list
-ros2 action info /{device_id}/my_action
-```
-
-### 查看 Service
-
-```bash
-ros2 service list
-ros2 service call /{device_id}/resource_list unilabos_msgs/srv/ResourceList
-```
-
-## 最佳实践
-
-1. **状态属性命名**: 使用蛇形命名法（snake_case）
-2. **Topic 频率**: 根据数据变化频率调整，避免过高频率
-3. **Action 反馈**: 长时间操作提供进度反馈
-4. **错误处理**: 使用 try-except 捕获并记录错误
-5. **资源清理**: 在 cleanup 方法中正确清理资源

.cursor/rules/testing-patterns.mdc

@@ -1,357 +0,0 @@
----
-description: 测试开发规范
-globs: ["tests/**/*.py", "**/test_*.py"]
----
-
-# 测试开发规范
-
-## 目录结构
-
-```
-tests/
-├── __init__.py
-├── devices/              # 设备测试
-│   └── liquid_handling/
-│       └── test_transfer_liquid.py
-├── resources/            # 资源测试
-│   ├── test_bottle_carrier.py
-│   └── test_resourcetreeset.py
-├── ros/                  # ROS消息测试
-│   └── msgs/
-│       ├── test_basic.py
-│       ├── test_conversion.py
-│       └── test_mapping.py
-└── workflow/             # 工作流测试
-    └── merge_workflow.py
-```
-
-## 测试框架
-
-使用 pytest 作为测试框架：
-
-```bash
-# 运行所有测试
-pytest tests/
-
-# 运行特定测试文件
-pytest tests/resources/test_bottle_carrier.py
-
-# 运行特定测试函数
-pytest tests/resources/test_bottle_carrier.py::test_bottle_carrier
-
-# 显示详细输出
-pytest -v tests/
-
-# 显示打印输出
-pytest -s tests/
-```
-
-## 测试文件模板
-
-```python
-import pytest
-from typing import List, Dict, Any
-
-# 导入被测试的模块
-from unilabos.resources.bioyond.bottle_carriers import (
-    BIOYOND_Electrolyte_6VialCarrier,
-)
-from unilabos.resources.bioyond.bottles import (
-    BIOYOND_PolymerStation_Solid_Vial,
-)
-
-
-class TestBottleCarrier:
-    """BottleCarrier 测试类"""
-
-    def setup_method(self):
-        """每个测试方法前执行"""
-        self.carrier = BIOYOND_Electrolyte_6VialCarrier("test_carrier")
-
-    def teardown_method(self):
-        """每个测试方法后执行"""
-        pass
-
-    def test_carrier_creation(self):
-        """测试载架创建"""
-        assert self.carrier.name == "test_carrier"
-        assert len(self.carrier.sites) == 6
-
-    def test_bottle_placement(self):
-        """测试瓶子放置"""
-        bottle = BIOYOND_PolymerStation_Solid_Vial("test_bottle")
-        # 测试逻辑...
-        assert bottle.name == "test_bottle"
-
-
-def test_standalone_function():
-    """独立测试函数"""
-    result = some_function()
-    assert result is True
-
-
-# 参数化测试
-@pytest.mark.parametrize("input,expected", [
-    ("5 min", 300.0),
-    ("1 h", 3600.0),
-    ("120", 120.0),
-    (60, 60.0),
-])
-def test_time_parsing(input, expected):
-    """测试时间解析"""
-    from unilabos.compile.utils.unit_parser import parse_time_input
-    assert parse_time_input(input) == expected
-
-
-# 异常测试
-def test_invalid_input_raises_error():
-    """测试无效输入抛出异常"""
-    with pytest.raises(ValueError) as exc_info:
-        invalid_function("bad_input")
-    assert "invalid" in str(exc_info.value).lower()
-
-
-# 跳过条件测试
-@pytest.mark.skipif(
-    not os.environ.get("ROS_DISTRO"),
-    reason="需要ROS环境"
-)
-def test_ros_feature():
-    """需要ROS环境的测试"""
-    pass
-```
-
-## 设备测试
-
-### 虚拟设备测试
-
-```python
-import pytest
-import asyncio
-from unittest.mock import MagicMock, AsyncMock
-
-from unilabos.devices.virtual.virtual_stirrer import VirtualStirrer
-
-
-class TestVirtualStirrer:
-    """VirtualStirrer 测试"""
-
-    @pytest.fixture
-    def stirrer(self):
-        """创建测试用搅拌器"""
-        device = VirtualStirrer(
-            device_id="test_stirrer",
-            config={"max_speed": 1500.0, "min_speed": 50.0}
-        )
-
-        # Mock ROS节点
-        mock_node = MagicMock()
-        mock_node.sleep = AsyncMock(return_value=None)
-        device.post_init(mock_node)
-
-        return device
-
-    @pytest.mark.asyncio
-    async def test_initialize(self, stirrer):
-        """测试初始化"""
-        result = await stirrer.initialize()
-        assert result is True
-        assert stirrer.status == "待机中"
-
-    @pytest.mark.asyncio
-    async def test_stir_action(self, stirrer):
-        """测试搅拌动作"""
-        await stirrer.initialize()
-
-        result = await stirrer.stir(
-            stir_time=5.0,
-            stir_speed=300.0,
-            settling_time=2.0
-        )
-
-        assert result is True
-        assert stirrer.operation_mode == "Completed"
-
-    @pytest.mark.asyncio
-    async def test_stir_invalid_speed(self, stirrer):
-        """测试无效速度"""
-        await stirrer.initialize()
-
-        # 速度超出范围
-        result = await stirrer.stir(
-            stir_time=5.0,
-            stir_speed=2000.0,  # 超过max_speed
-            settling_time=0.0
-        )
-
-        assert result is False
-        assert "错误" in stirrer.status
-```
-
-### 异步测试配置
-
-```python
-# conftest.py
-import pytest
-import asyncio
-
-
-@pytest.fixture(scope="session")
-def event_loop():
-    """创建事件循环"""
-    loop = asyncio.get_event_loop_policy().new_event_loop()
-    yield loop
-    loop.close()
-```
-
-## 资源测试
-
-```python
-import pytest
-from unilabos.resources.resource_tracker import (
-    ResourceTreeSet,
-    ResourceTreeInstance,
-)
-
-
-def test_resource_tree_creation():
-    """测试资源树创建"""
-    tree_set = ResourceTreeSet()
-
-    # 添加资源
-    resource = {"id": "res_1", "name": "Resource 1"}
-    tree_set.add_resource(resource)
-
-    # 验证
-    assert len(tree_set.all_nodes) == 1
-    assert tree_set.get_resource("res_1") is not None
-
-
-def test_resource_tree_merge():
-    """测试资源树合并"""
-    local_set = ResourceTreeSet()
-    remote_set = ResourceTreeSet()
-
-    # 设置数据...
-
-    local_set.merge_remote_resources(remote_set)
-
-    # 验证合并结果...
-```
-
-## ROS 消息测试
-
-```python
-import pytest
-from unilabos.ros.msgs.message_converter import (
-    convert_to_ros_msg,
-    convert_from_ros_msg_with_mapping,
-    msg_converter_manager,
-)
-
-
-def test_message_conversion():
-    """测试消息转换"""
-    # Python -> ROS
-    python_data = {"id": "test", "value": 42}
-    ros_msg = convert_to_ros_msg(python_data, MyMsgType)
-
-    assert ros_msg.id == "test"
-    assert ros_msg.value == 42
-
-    # ROS -> Python
-    result = convert_from_ros_msg_with_mapping(ros_msg, mapping)
-    assert result["id"] == "test"
-```
-
-## 协议测试
-
-```python
-import pytest
-import networkx as nx
-from unilabos.compile.stir_protocol import (
-    generate_stir_protocol,
-    extract_vessel_id,
-)
-
-
-@pytest.fixture
-def topology_graph():
-    """创建测试拓扑图"""
-    G = nx.DiGraph()
-    G.add_node("flask_1", **{"class": "flask"})
-    G.add_node("stirrer_1", **{"class": "virtual_stirrer"})
-    G.add_edge("stirrer_1", "flask_1")
-    return G
-
-
-def test_generate_stir_protocol(topology_graph):
-    """测试搅拌协议生成"""
-    actions = generate_stir_protocol(
-        G=topology_graph,
-        vessel="flask_1",
-        time="5 min",
-        stir_speed=300.0
-    )
-
-    assert len(actions) == 1
-    assert actions[0]["device_id"] == "stirrer_1"
-    assert actions[0]["action_name"] == "stir"
-
-
-def test_extract_vessel_id():
-    """测试vessel_id提取"""
-    # 字典格式
-    assert extract_vessel_id({"id": "flask_1"}) == "flask_1"
-
-    # 字符串格式
-    assert extract_vessel_id("flask_2") == "flask_2"
-
-    # 空值
-    assert extract_vessel_id("") == ""
-```
-
-## 测试标记
-
-```python
-# 慢速测试
-@pytest.mark.slow
-def test_long_running():
-    pass
-
-# 需要网络
-@pytest.mark.network
-def test_network_call():
-    pass
-
-# 需要ROS
-@pytest.mark.ros
-def test_ros_feature():
-    pass
-```
-
-运行特定标记的测试：
-
-```bash
-pytest -m "not slow"  # 排除慢速测试
-pytest -m ros         # 仅ROS测试
-```
-
-## 覆盖率
-
-```bash
-# 生成覆盖率报告
-pytest --cov=unilabos tests/
-
-# HTML报告
-pytest --cov=unilabos --cov-report=html tests/
-```
-
-## 最佳实践
-
-1. **测试命名**: `test_{功能}_{场景}_{预期结果}`
-2. **独立性**: 每个测试独立运行，不依赖其他测试
-3. **Mock外部依赖**: 使用 unittest.mock 模拟外部服务
-4. **参数化**: 使用 `@pytest.mark.parametrize` 减少重复代码
-5. **fixtures**: 使用 fixtures 共享测试设置
-6. **断言清晰**: 每个断言只验证一件事

.cursor/rules/unilabos-project.mdc

@@ -1,353 +0,0 @@
----
-description: Uni-Lab-OS 实验室自动化平台开发规范 - 核心规则
-globs: ["**/*.py", "**/*.yaml", "**/*.json"]
----
-
-# Uni-Lab-OS 项目开发规范
-
-## 项目概述
-
-Uni-Lab-OS 是一个实验室自动化操作系统，用于连接和控制各种实验设备，实现实验工作流的自动化和标准化。
-
-## 技术栈
-
-- **Python 3.11** - 核心开发语言
-- **ROS 2** - 设备通信中间件 (rclpy)
-- **Conda/Mamba** - 包管理 (robostack-staging, conda-forge)
-- **FastAPI** - Web API 服务
-- **WebSocket** - 实时通信
-- **NetworkX** - 拓扑图管理
-- **YAML** - 配置和注册表定义
-- **PyLabRobot** - 实验室自动化库集成
-- **pytest** - 测试框架
-- **asyncio** - 异步编程
-
-## 项目结构
-
-```
-unilabos/
-├── app/           # 应用入口、Web服务、后端
-├── compile/       # 协议编译器 (stir, add, filter 等)
-├── config/        # 配置管理
-├── devices/       # 设备驱动 (真实/虚拟)
-├── device_comms/  # 设备通信协议
-├── device_mesh/   # 3D网格和可视化
-├── registry/      # 设备和资源类型注册表 (YAML)
-├── resources/     # 资源定义
-├── ros/           # ROS 2 集成
-├── utils/         # 工具函数
-└── workflow/      # 工作流管理
-```
-
-## 代码规范
-
-### Python 风格
-
-1. **类型注解**：所有函数必须使用类型注解
-   ```python
-   def transfer_liquid(
-       source: str,
-       destination: str,
-       volume: float,
-       **kwargs
-   ) -> List[Dict[str, Any]]:
-   ```
-
-2. **Docstring**：使用 Google 风格的文档字符串
-   ```python
-   def initialize(self) -> bool:
-       """
-       初始化设备
-
-       Returns:
-           bool: 初始化是否成功
-       """
-   ```
-
-3. **导入顺序**：
-   - 标准库
-   - 第三方库
-   - ROS 相关 (rclpy, unilabos_msgs)
-   - 项目内部模块
-
-### 异步编程
-
-1. 设备操作方法使用 `async def`
-2. 使用 `await self._ros_node.sleep()` 而非 `asyncio.sleep()`
-3. 长时间运行操作需提供进度反馈
-
-```python
-async def stir(self, stir_time: float, stir_speed: float, **kwargs) -> bool:
-    """执行搅拌操作"""
-    start_time = time_module.time()
-    while True:
-        elapsed = time_module.time() - start_time
-        remaining = max(0, stir_time - elapsed)
-
-        self.data.update({
-            "remaining_time": remaining,
-            "status": f"搅拌中: {stir_speed} RPM"
-        })
-
-        if remaining <= 0:
-            break
-        await self._ros_node.sleep(1.0)
-    return True
-```
-
-### 日志规范
-
-使用项目自定义日志系统：
-
-```python
-from unilabos.utils.log import logger, info, debug, warning, error, trace
-
-# 在设备类中使用
-self.logger = logging.getLogger(f"DeviceName.{self.device_id}")
-self.logger.info("设备初始化完成")
-```
-
-## 设备驱动开发
-
-### 设备类结构
-
-```python
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-
-class MyDevice:
-    """设备驱动类"""
-
-    _ros_node: BaseROS2DeviceNode
-
-    def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
-        self.device_id = device_id or "unknown_device"
-        self.config = config or {}
-        self.data = {}  # 设备状态数据
-
-    def post_init(self, ros_node: BaseROS2DeviceNode):
-        """ROS节点注入"""
-        self._ros_node = ros_node
-
-    async def initialize(self) -> bool:
-        """初始化设备"""
-        pass
-
-    async def cleanup(self) -> bool:
-        """清理设备"""
-        pass
-
-    # 状态属性 - 自动发布为 ROS Topic
-    @property
-    def status(self) -> str:
-        return self.data.get("status", "待机")
-```
-
-### 状态属性装饰器
-
-```python
-from unilabos.utils.decorator import topic_config
-
-class MyDevice:
-    @property
-    @topic_config(period=1.0, qos=10)  # 每秒发布一次
-    def temperature(self) -> float:
-        return self._temperature
-```
-
-### 虚拟设备
-
-虚拟设备放置在 `unilabos/devices/virtual/` 目录下，命名为 `virtual_*.py`
-
-## 注册表配置
-
-### 设备注册表 (YAML)
-
-位置: `unilabos/registry/devices/*.yaml`
-
-```yaml
-my_device_type:
-  category:
-    - my_category
-  description: "设备描述"
-  version: "1.0.0"
-  class:
-    module: "unilabos.devices.my_device:MyDevice"
-    type: python
-    status_types:
-      status: String
-      temperature: Float64
-    action_value_mappings:
-      auto-initialize:
-        type: UniLabJsonCommandAsync
-        goal: {}
-        feedback: {}
-        result: {}
-        schema: {...}
-```
-
-### 资源注册表 (YAML)
-
-位置: `unilabos/registry/resources/**/*.yaml`
-
-```yaml
-my_container:
-  category:
-    - container
-  class:
-    module: "unilabos.resources.my_resource:MyContainer"
-    type: pylabrobot
-  version: "1.0.0"
-```
-
-## 协议编译器
-
-位置: `unilabos/compile/*_protocol.py`
-
-### 协议生成函数模板
-
-```python
-from typing import List, Dict, Any, Union
-import networkx as nx
-
-def generate_my_protocol(
-    G: nx.DiGraph,
-    vessel: Union[str, dict],
-    param1: float = 0.0,
-    **kwargs
-) -> List[Dict[str, Any]]:
-    """
-    生成操作协议序列
-
-    Args:
-        G: 物理拓扑图
-        vessel: 容器ID或字典
-        param1: 参数1
-
-    Returns:
-        List[Dict]: 动作序列
-    """
-    # 提取vessel_id
-    vessel_id = vessel if isinstance(vessel, str) else vessel.get("id", "")
-
-    # 查找设备
-    device_id = find_connected_device(G, vessel_id)
-
-    # 生成动作
-    action_sequence = [{
-        "device_id": device_id,
-        "action_name": "my_action",
-        "action_kwargs": {
-            "vessel": {"id": vessel_id},
-            "param1": float(param1)
-        }
-    }]
-
-    return action_sequence
-```
-
-## 测试规范
-
-### 测试文件位置
-
-- 单元测试: `tests/` 目录
-- 设备测试: `tests/devices/`
-- 资源测试: `tests/resources/`
-- ROS消息测试: `tests/ros/msgs/`
-
-### 测试命名
-
-```python
-# tests/devices/my_device/test_my_device.py
-
-import pytest
-
-def test_device_initialization():
-    """测试设备初始化"""
-    pass
-
-def test_device_action():
-    """测试设备动作"""
-    pass
-```
-
-## 错误处理
-
-```python
-from unilabos.utils.exception import UniLabException
-
-try:
-    result = await device.execute_action()
-except ValueError as e:
-    self.logger.error(f"参数错误: {e}")
-    self.data["status"] = "错误: 参数无效"
-    return False
-except Exception as e:
-    self.logger.error(f"执行失败: {e}")
-    raise
-```
-
-## 配置管理
-
-```python
-from unilabos.config.config import BasicConfig, HTTPConfig
-
-# 读取配置
-port = BasicConfig.port
-is_host = BasicConfig.is_host_mode
-
-# 配置文件: local_config.py
-```
-
-## 常用工具
-
-### 单例模式
-
-```python
-from unilabos.utils.decorator import singleton
-
-@singleton
-class MyManager:
-    pass
-```
-
-### 类型检查
-
-```python
-from unilabos.utils.type_check import NoAliasDumper
-
-yaml.dump(data, f, Dumper=NoAliasDumper)
-```
-
-### 导入管理
-
-```python
-from unilabos.utils.import_manager import get_class
-
-device_class = get_class("unilabos.devices.my_device:MyDevice")
-```
-
-## Git 提交规范
-
-提交信息格式:
-```
-<type>(<scope>): <subject>
-
-<body>
-```
-
-类型:
-- `feat`: 新功能
-- `fix`: 修复bug
-- `docs`: 文档更新
-- `refactor`: 重构
-- `test`: 测试相关
-- `chore`: 构建/工具相关
-
-示例:
-```
-feat(devices): 添加虚拟搅拌器设备
-
-- 实现VirtualStirrer类
-- 支持定时搅拌和持续搅拌模式
-- 添加速度验证逻辑
-```

.cursor/skills/add-device/SKILL.md

@@ -1,160 +0,0 @@
----
-name: add-device
-description: Guide for adding new devices to Uni-Lab-OS (接入新设备). Uses @device decorator + AST auto-scanning instead of manual YAML. Walks through device category, communication protocol, driver creation with decorators, and graph file setup. Use when the user wants to add/integrate a new device, create a device driver, write a device class, or mentions 接入设备/添加设备/设备驱动/物模型.
----
-
-# 添加新设备到 Uni-Lab-OS
-
-**第一步：** 使用 Read 工具读取 `docs/ai_guides/add_device.md`，获取完整的设备接入指南。
-
-该指南包含设备类别（物模型）列表、通信协议模板、常见错误检查清单等。搜索 `unilabos/devices/` 获取已有设备的实现参考。
-
----
-
-## 装饰器参考
-
-### @device — 设备类装饰器
-
-```python
-from unilabos.registry.decorators import device
-
-# 单设备
-@device(
-    id="my_device.vendor",           # 注册表唯一标识（必填）
-    category=["temperature"],         # 分类标签列表（必填）
-    description="设备描述",            # 设备描述
-    display_name="显示名称",           # UI 显示名称（默认用 id）
-    icon="DeviceIcon.webp",           # 图标文件名
-    version="1.0.0",                  # 版本号
-    device_type="python",             # "python" 或 "ros2"
-    handles=[...],                    # 端口列表（InputHandle / OutputHandle）
-    model={...},                      # 3D 模型配置
-    hardware_interface=HardwareInterface(...),  # 硬件通信接口
-)
-
-# 多设备（同一个类注册多个设备 ID，各自有不同的 handles 等配置）
-@device(
-    ids=["pump.vendor.model_A", "pump.vendor.model_B"],
-    id_meta={
-        "pump.vendor.model_A": {"handles": [...], "description": "型号 A"},
-        "pump.vendor.model_B": {"handles": [...], "description": "型号 B"},
-    },
-    category=["pump_and_valve"],
-)
-```
-
-### @action — 动作方法装饰器
-
-```python
-from unilabos.registry.decorators import action
-
-@action                              # 无参：注册为 UniLabJsonCommand 动作
-@action()                            # 同上
-@action(description="执行操作")       # 带描述
-@action(
-    action_type=HeatChill,           # 指定 ROS Action 消息类型
-    goal={"temperature": "temp"},    # Goal 字段映射
-    feedback={},                     # Feedback 字段映射
-    result={},                       # Result 字段映射
-    handles=[...],                   # 动作级别端口
-    goal_default={"temp": 25.0},     # Goal 默认值
-    placeholder_keys={...},          # 参数占位符
-    always_free=True,                # 不受排队限制
-    auto_prefix=True,                # 强制使用 auto- 前缀
-    parent=True,                     # 从父类 MRO 获取参数签名
-)
-```
-
-**自动识别规则：**
-- 带 `@action` 的公开方法 → 注册为动作（方法名即动作名）
-- **不带 `@action` 的公开方法** → 自动注册为 `auto-{方法名}` 动作
-- `_` 开头的方法 → 不扫描
-- `@not_action` 标记的方法 → 排除
-
-### @topic_config — 状态属性配置
-
-```python
-from unilabos.registry.decorators import topic_config
-
-@property
-@topic_config(
-    period=5.0,            # 发布周期（秒），默认 5.0
-    print_publish=False,   # 是否打印发布日志
-    qos=10,                # QoS 深度，默认 10
-    name="custom_name",    # 自定义发布名称（默认用属性名）
-)
-def temperature(self) -> float:
-    return self.data.get("temperature", 0.0)
-```
-
-### 辅助装饰器
-
-```python
-from unilabos.registry.decorators import not_action, always_free
-
-@not_action          # 标记为非动作（post_init、辅助方法等）
-@always_free         # 标记为不受排队限制（查询类操作）
-```
-
----
-
-## 设备模板
-
-```python
-import logging
-from typing import Any, Dict, Optional
-
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.registry.decorators import device, action, topic_config, not_action
-
-@device(id="my_device", category=["my_category"], description="设备描述")
-class MyDevice:
-    _ros_node: BaseROS2DeviceNode
-
-    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
-        self.device_id = device_id or "my_device"
-        self.config = config or {}
-        self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
-        self.data: Dict[str, Any] = {"status": "Idle"}
-
-    @not_action
-    def post_init(self, ros_node: BaseROS2DeviceNode) -> None:
-        self._ros_node = ros_node
-
-    @action
-    async def initialize(self) -> bool:
-        self.data["status"] = "Ready"
-        return True
-
-    @action
-    async def cleanup(self) -> bool:
-        self.data["status"] = "Offline"
-        return True
-
-    @action(description="执行操作")
-    def my_action(self, param: float = 0.0, name: str = "") -> Dict[str, Any]:
-        """带 @action 装饰器 → 注册为 'my_action' 动作"""
-        return {"success": True}
-
-    def get_info(self) -> Dict[str, Any]:
-        """无 @action → 自动注册为 'auto-get_info' 动作"""
-        return {"device_id": self.device_id}
-
-    @property
-    @topic_config()
-    def status(self) -> str:
-        return self.data.get("status", "Idle")
-
-    @property
-    @topic_config(period=2.0)
-    def temperature(self) -> float:
-        return self.data.get("temperature", 0.0)
-```
-
-### 要点
-
-- `_ros_node: BaseROS2DeviceNode` 类型标注放在类体顶部
-- `__init__` 签名固定为 `(self, device_id=None, config=None, **kwargs)`
-- `post_init` 用 `@not_action` 标记，参数类型标注为 `BaseROS2DeviceNode`
-- 运行时状态存储在 `self.data` 字典中
-- 设备文件放在 `unilabos/devices/<category>/` 目录下

.cursor/skills/add-resource/SKILL.md

@@ -1,351 +0,0 @@
----
-name: add-resource
-description: Guide for adding new resources (materials, bottles, carriers, decks, warehouses) to Uni-Lab-OS (添加新物料/资源). Uses @resource decorator for AST auto-scanning. Covers Bottle, Carrier, Deck, WareHouse definitions. Use when the user wants to add resources, define materials, create a deck layout, add bottles/carriers/plates, or mentions 物料/资源/resource/bottle/carrier/deck/plate/warehouse.
----
-
-# 添加新物料资源
-
-Uni-Lab-OS 的资源体系基于 PyLabRobot，通过扩展实现 Bottle、Carrier、WareHouse、Deck 等实验室物料管理。使用 `@resource` 装饰器注册，AST 自动扫描生成注册表条目。
-
----
-
-## 资源类型
-
-| 类型 | 基类 | 用途 | 示例 |
-|------|------|------|------|
-| **Bottle** | `Well` (PyLabRobot) | 单个容器（瓶、小瓶、烧杯、反应器） | 试剂瓶、粉末瓶 |
-| **BottleCarrier** | `ItemizedCarrier` | 多槽位载架（放多个 Bottle） | 6 位试剂架、枪头盒 |
-| **WareHouse** | `ItemizedCarrier` | 堆栈/仓库（放多个 Carrier） | 4x4 堆栈 |
-| **Deck** | `Deck` (PyLabRobot) | 工作站台面（放多个 WareHouse） | 反应站 Deck |
-
-**层级关系：** `Deck` → `WareHouse` → `BottleCarrier` → `Bottle`
-
-WareHouse 本质上和 Site 是同一概念 — 都是定义一组固定的放置位（slot），只不过 WareHouse 多嵌套了一层 Deck。两者都需要开发者根据实际物理尺寸自行计算各 slot 的偏移坐标。
-
----
-
-## @resource 装饰器
-
-```python
-from unilabos.registry.decorators import resource
-
-@resource(
-    id="my_resource_id",        # 注册表唯一标识（必填）
-    category=["bottles"],       # 分类标签列表（必填）
-    description="资源描述",
-    icon="",                    # 图标
-    version="1.0.0",
-    handles=[...],              # 端口列表（InputHandle / OutputHandle）
-    model={...},                # 3D 模型配置
-    class_type="pylabrobot",    # "python" / "pylabrobot" / "unilabos"
-)
-```
-
----
-
-## 创建规范
-
-### 命名规则
-
-1. **`name` 参数作为前缀**：所有工厂函数必须接受 `name: str` 参数，创建子物料时以 `name` 作为前缀，确保实例名在运行时全局唯一
-2. **Bottle 命名约定**：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
-3. **函数名 = `@resource(id=...)`**：工厂函数名与注册表 id 保持一致
-
-### 子物料命名示例
-
-```python
-# Carrier 内部的 sites 用 name 前缀
-for k, v in sites.items():
-    v.name = f"{name}_{v.name}"     # "堆栈1左_A01", "堆栈1左_B02" ...
-
-# Carrier 中放置 Bottle 时用 name 前缀
-carrier[0] = My_Reagent_Bottle(f"{name}_flask_1")    # "堆栈1左_flask_1"
-carrier[i] = My_Solid_Vial(f"{name}_vial_{ordering[i]}")  # "堆栈1左_vial_A1"
-
-# create_homogeneous_resources 使用 name_prefix
-sites=create_homogeneous_resources(
-    klass=ResourceHolder,
-    locations=[...],
-    name_prefix=name,  # 自动生成 "{name}_0", "{name}_1" ...
-)
-
-# Deck setup 中用仓库名称作为 name 传入
-self.warehouses = {
-    "堆栈1左": my_warehouse_4x4("堆栈1左"),   # WareHouse.name = "堆栈1左"
-    "试剂堆栈": my_reagent_stack("试剂堆栈"),  # WareHouse.name = "试剂堆栈"
-}
-```
-
-### 其他规范
-
-- **max_volume 单位为 μL**：500mL = 500000
-- **尺寸单位为 mm**：`diameter`, `height`, `size_x/y/z`, `dx/dy/dz`
-- **BottleCarrier 必须设置 `num_items_x/y/z`**：用于前端渲染布局
-- **Deck 的 `__init__` 必须接受 `setup=False`**：图文件中 `config.setup=true` 触发 `setup()`
-- **按项目分组文件**：同一工作站的资源放在 `unilabos/resources/<project>/` 下
-- **`__init__` 必须接受 `serialize()` 输出的所有字段**：`serialize()` 输出会作为 `config` 回传到 `__init__`，因此必须通过显式参数或 `**kwargs` 接受，否则反序列化会报错
-- **持久化运行时状态用 `serialize_state()`**：通过 `_unilabos_state` 字典存储可变信息（如物料内容、液体量），只存 JSON 可序列化的基本类型
-
----
-
-## 资源模板
-
-### Bottle
-
-```python
-from unilabos.registry.decorators import resource
-from unilabos.resources.itemized_carrier import Bottle
-
-
-@resource(id="My_Reagent_Bottle", category=["bottles"], description="我的试剂瓶")
-def My_Reagent_Bottle(
-    name: str,
-    diameter: float = 70.0,
-    height: float = 120.0,
-    max_volume: float = 500000.0,
-    barcode: str = None,
-) -> Bottle:
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="My_Reagent_Bottle",
-    )
-```
-
-**Bottle 参数：**
-- `name`: 实例名称（运行时唯一，由上层 Carrier 以前缀方式传入）
-- `diameter`: 瓶体直径 (mm)
-- `height`: 瓶体高度 (mm)
-- `max_volume`: 最大容积（**μL**，500mL = 500000）
-- `barcode`: 条形码（可选）
-
-### BottleCarrier
-
-```python
-from pylabrobot.resources import ResourceHolder
-from pylabrobot.resources.carrier import create_ordered_items_2d
-from unilabos.resources.itemized_carrier import BottleCarrier
-from unilabos.registry.decorators import resource
-
-
-@resource(id="My_6SlotCarrier", category=["bottle_carriers"], description="六槽位载架")
-def My_6SlotCarrier(name: str) -> BottleCarrier:
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=3, num_items_y=2,
-        dx=10.0, dy=10.0, dz=5.0,
-        item_dx=42.0, item_dy=35.0,
-        size_x=20.0, size_y=20.0, size_z=50.0,
-    )
-    # 子 site 用 name 作为前缀
-    for k, v in sites.items():
-        v.name = f"{name}_{v.name}"
-
-    carrier = BottleCarrier(
-        name=name, size_x=146.0, size_y=80.0, size_z=55.0,
-        sites=sites, model="My_6SlotCarrier",
-    )
-    carrier.num_items_x = 3
-    carrier.num_items_y = 2
-    carrier.num_items_z = 1
-
-    # 放置 Bottle 时用 name 作为前缀
-    ordering = ["A1", "B1", "A2", "B2", "A3", "B3"]
-    for i in range(6):
-        carrier[i] = My_Reagent_Bottle(f"{name}_vial_{ordering[i]}")
-    return carrier
-```
-
-### WareHouse / Deck 放置位
-
-WareHouse 和 Site 本质上是同一概念：都是定义一组固定放置位（slot），根据物理尺寸自行批量计算偏移坐标。WareHouse 只是多嵌套了一层 Deck 而已。推荐开发者直接根据实物测量数据计算各 slot 偏移量。
-
-#### WareHouse（使用 warehouse_factory）
-
-```python
-from unilabos.resources.warehouse import warehouse_factory
-from unilabos.registry.decorators import resource
-
-
-@resource(id="my_warehouse_4x4", category=["warehouse"], description="4x4 堆栈仓库")
-def my_warehouse_4x4(name: str) -> "WareHouse":
-    return warehouse_factory(
-        name=name,
-        num_items_x=4, num_items_y=4, num_items_z=1,
-        dx=10.0, dy=10.0, dz=10.0,             # 第一个 slot 的起始偏移
-        item_dx=147.0, item_dy=106.0, item_dz=130.0,  # slot 间距
-        resource_size_x=127.0, resource_size_y=85.0, resource_size_z=100.0,  # slot 尺寸
-        model="my_warehouse_4x4",
-        col_offset=0,       # 列标签起始偏移（0 → A01, 4 → A05）
-        layout="row-major",  # "row-major" 行优先 / "col-major" 列优先 / "vertical-col-major" 竖向
-    )
-```
-
-`warehouse_factory` 参数说明：
-- `dx/dy/dz`：第一个 slot 相对 WareHouse 原点的偏移（mm）
-- `item_dx/item_dy/item_dz`：相邻 slot 间距（mm），需根据实际物理间距测量
-- `resource_size_x/y/z`：每个 slot 的可放置区域尺寸
-- `layout`：影响 slot 标签和坐标映射
-  - `"row-major"`：A01,A02,...,B01,B02,...（行优先，适合横向排列）
-  - `"col-major"`：A01,B01,...,A02,B02,...（列优先）
-  - `"vertical-col-major"`：竖向排列，y 坐标反向
-
-#### Deck 组装 WareHouse
-
-Deck 通过 `setup()` 将多个 WareHouse 放置到指定坐标：
-
-```python
-from pylabrobot.resources import Deck, Coordinate
-from unilabos.registry.decorators import resource
-
-
-@resource(id="MyStation_Deck", category=["deck"], description="我的工作站 Deck")
-class MyStation_Deck(Deck):
-    def __init__(self, name="MyStation_Deck", size_x=2700.0, size_y=1080.0, size_z=1500.0,
-                 category="deck", setup=False, **kwargs) -> None:
-        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
-        if setup:
-            self.setup()
-
-    def setup(self) -> None:
-        self.warehouses = {
-            "堆栈1左": my_warehouse_4x4("堆栈1左"),
-            "堆栈1右": my_warehouse_4x4("堆栈1右"),
-        }
-        self.warehouse_locations = {
-            "堆栈1左": Coordinate(-200.0, 400.0, 0.0),  # 自行测量计算
-            "堆栈1右": Coordinate(2350.0, 400.0, 0.0),
-        }
-        for wh_name, wh in self.warehouses.items():
-            self.assign_child_resource(wh, location=self.warehouse_locations[wh_name])
-```
-
-#### Site 模式（前端定向放置）
-
-适用于有固定孔位/槽位的设备（如移液站 PRCXI 9300），Deck 通过 `sites` 列表定义前端展示的放置位，前端据此渲染可拖拽的孔位布局：
-
-```python
-import collections
-from typing import Any, Dict, List, Optional
-from pylabrobot.resources import Deck, Resource, Coordinate
-from unilabos.registry.decorators import resource
-
-
-@resource(id="MyLabDeck", category=["deck"], description="带 Site 定向放置的 Deck")
-class MyLabDeck(Deck):
-    # 根据设备台面实测批量计算各 slot 坐标偏移
-    _DEFAULT_SITE_POSITIONS = [
-        (0, 0, 0), (138, 0, 0), (276, 0, 0), (414, 0, 0),       # T1-T4
-        (0, 96, 0), (138, 96, 0), (276, 96, 0), (414, 96, 0),   # T5-T8
-    ]
-    _DEFAULT_SITE_SIZE = {"width": 128.0, "height": 86.0, "depth": 0}
-    _DEFAULT_CONTENT_TYPE = ["plate", "tip_rack", "tube_rack", "adaptor"]
-
-    def __init__(self, name: str, size_x: float, size_y: float, size_z: float,
-                 sites: Optional[List[Dict[str, Any]]] = None, **kwargs):
-        super().__init__(size_x, size_y, size_z, name)
-        if sites is not None:
-            self.sites = [dict(s) for s in sites]
-        else:
-            self.sites = []
-            for i, (x, y, z) in enumerate(self._DEFAULT_SITE_POSITIONS):
-                self.sites.append({
-                    "label": f"T{i + 1}",          # 前端显示的槽位标签
-                    "visible": True,                # 是否在前端可见
-                    "position": {"x": x, "y": y, "z": z},  # 槽位物理坐标
-                    "size": dict(self._DEFAULT_SITE_SIZE),  # 槽位尺寸
-                    "content_type": list(self._DEFAULT_CONTENT_TYPE),  # 允许放入的物料类型
-                })
-        self._ordering = collections.OrderedDict(
-            (site["label"], None) for site in self.sites
-        )
-
-    def assign_child_resource(self, resource: Resource,
-                              location: Optional[Coordinate] = None,
-                              reassign: bool = True,
-                              spot: Optional[int] = None):
-        idx = spot
-        if spot is None:
-            for i, site in enumerate(self.sites):
-                if site.get("label") == resource.name:
-                    idx = i
-                    break
-        if idx is None:
-            for i in range(len(self.sites)):
-                if self._get_site_resource(i) is None:
-                    idx = i
-                    break
-        if idx is None:
-            raise ValueError(f"No available site for '{resource.name}'")
-        loc = Coordinate(**self.sites[idx]["position"])
-        super().assign_child_resource(resource, location=loc, reassign=reassign)
-
-    def serialize(self) -> dict:
-        data = super().serialize()
-        sites_out = []
-        for i, site in enumerate(self.sites):
-            occupied = self._get_site_resource(i)
-            sites_out.append({
-                "label": site["label"],
-                "visible": site.get("visible", True),
-                "occupied_by": occupied.name if occupied else None,
-                "position": site["position"],
-                "size": site["size"],
-                "content_type": site["content_type"],
-            })
-        data["sites"] = sites_out
-        return data
-```
-
-**Site 字段说明：**
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `label` | str | 槽位标签（如 `"T1"`），前端显示名称，也用于匹配 resource.name |
-| `visible` | bool | 是否在前端可见 |
-| `position` | dict | 物理坐标 `{x, y, z}`（mm），需自行测量计算偏移 |
-| `size` | dict | 槽位尺寸 `{width, height, depth}`（mm） |
-| `content_type` | list | 允许放入的物料类型，如 `["plate", "tip_rack", "tube_rack", "adaptor"]` |
-
-**参考实现：** `unilabos/devices/liquid_handling/prcxi/prcxi.py` 中的 `PRCXI9300Deck`（4x4 共 16 个 site）。
-
----
-
-## 文件位置
-
-```
-unilabos/resources/
-├── <project>/              # 按项目分组
-│   ├── bottles.py          # Bottle 工厂函数
-│   ├── bottle_carriers.py  # Carrier 工厂函数
-│   ├── warehouses.py       # WareHouse 工厂函数
-│   └── decks.py            # Deck 类定义
-```
-
----
-
-## 验证
-
-```bash
-# 资源可导入
-python -c "from unilabos.resources.my_project.bottles import My_Reagent_Bottle; print(My_Reagent_Bottle('test'))"
-
-# 启动测试（AST 自动扫描）
-unilab -g <graph>.json
-```
-
-仅在以下情况仍需 YAML：第三方库资源（如 pylabrobot 内置资源，无 `@resource` 装饰器）。
-
----
-
-## 关键路径
-
-| 内容 | 路径 |
-|------|------|
-| Bottle/Carrier 基类 | `unilabos/resources/itemized_carrier.py` |
-| WareHouse 基类 + 工厂 | `unilabos/resources/warehouse.py` |
-| PLR 注册 | `unilabos/resources/plr_additional_res_reg.py` |
-| 装饰器定义 | `unilabos/registry/decorators.py` |

.cursor/skills/add-resource/reference.md

@@ -1,292 +0,0 @@
-# 资源高级参考
-
-本文件是 SKILL.md 的补充，包含类继承体系、序列化/反序列化、Bioyond 物料同步、非瓶类资源和仓库工厂模式。Agent 在需要实现这些功能时按需阅读。
-
----
-
-## 1. 类继承体系
-
-```
-PyLabRobot
-├── Resource (PLR 基类)
-│   ├── Well
-│   │   └── Bottle (unilabos)        → 瓶/小瓶/烧杯/反应器
-│   ├── Deck
-│   │   └── 自定义 Deck 类 (unilabos) → 工作站台面
-│   ├── ResourceHolder               → 槽位占位符
-│   └── Container
-│       └── Battery (unilabos)       → 组装好的电池
-│
-├── ItemizedCarrier (unilabos, 继承 Resource)
-│   ├── BottleCarrier (unilabos)     → 瓶载架
-│   └── WareHouse (unilabos)         → 堆栈仓库
-│
-├── ItemizedResource (PLR)
-│   └── MagazineHolder (unilabos)    → 子弹夹载架
-│
-└── ResourceStack (PLR)
-    └── Magazine (unilabos)          → 子弹夹洞位
-```
-
-### Bottle 类细节
-
-```python
-class Bottle(Well):
-    def __init__(self, name, diameter, height, max_volume,
-                 size_x=0.0, size_y=0.0, size_z=0.0,
-                 barcode=None, category="container", model=None, **kwargs):
-        super().__init__(
-            name=name,
-            size_x=diameter,    # PLR 用 diameter 作为 size_x/size_y
-            size_y=diameter,
-            size_z=height,      # PLR 用 height 作为 size_z
-            max_volume=max_volume,
-            category=category,
-            model=model,
-            bottom_type="flat",
-            cross_section_type="circle"
-        )
-```
-
-注意 `size_x = size_y = diameter`，`size_z = height`。
-
-### ItemizedCarrier 核心方法
-
-| 方法 | 说明 |
-|------|------|
-| `__getitem__(identifier)` | 通过索引或 Excel 标识（如 `"A01"`）访问槽位 |
-| `__setitem__(identifier, resource)` | 向槽位放入资源 |
-| `get_child_identifier(child)` | 获取子资源的标识符 |
-| `capacity` | 总槽位数 |
-| `sites` | 所有槽位字典 |
-
----
-
-## 2. 序列化与反序列化
-
-### PLR ↔ UniLab 转换
-
-| 函数 | 位置 | 方向 |
-|------|------|------|
-| `ResourceTreeSet.from_plr_resources(resources)` | `resource_tracker.py` | PLR → UniLab |
-| `ResourceTreeSet.to_plr_resources()` | `resource_tracker.py` | UniLab → PLR |
-
-### `from_plr_resources` 流程
-
-```
-PLR Resource
-    ↓ build_uuid_mapping (递归生成 UUID)
-    ↓ resource.serialize() → dict
-    ↓ resource.serialize_all_state() → states
-    ↓ resource_plr_inner (递归构建 ResourceDictInstance)
-ResourceTreeSet
-```
-
-关键：每个 PLR 资源通过 `unilabos_uuid` 属性携带 UUID，`unilabos_extra` 携带扩展数据（如 `class` 名）。
-
-### `to_plr_resources` 流程
-
-```
-ResourceTreeSet
-    ↓ collect_node_data (收集 UUID、状态、扩展数据)
-    ↓ node_to_plr_dict (转为 PLR 字典格式)
-    ↓ find_subclass(type_name, PLRResource) (查找 PLR 子类)
-    ↓ sub_cls.deserialize(plr_dict) (反序列化)
-    ↓ loop_set_uuid, loop_set_extra (递归设置 UUID 和扩展)
-PLR Resource
-```
-
-### Bottle 序列化
-
-```python
-class Bottle(Well):
-    def serialize(self) -> dict:
-        data = super().serialize()
-        return {**data, "diameter": self.diameter, "height": self.height}
-
-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal=False):
-        barcode_data = data.pop("barcode", None)
-        instance = super().deserialize(data, allow_marshal=allow_marshal)
-        if barcode_data and isinstance(barcode_data, str):
-            instance.barcode = barcode_data
-        return instance
-```
-
----
-
-## 3. Bioyond 物料同步
-
-### 双向转换函数
-
-| 函数 | 位置 | 方向 |
-|------|------|------|
-| `resource_bioyond_to_plr(materials, type_mapping, deck)` | `graphio.py` | Bioyond → PLR |
-| `resource_plr_to_bioyond(resources, type_mapping, warehouse_mapping)` | `graphio.py` | PLR → Bioyond |
-
-### `resource_bioyond_to_plr` 流程
-
-```
-Bioyond 物料列表
-    ↓ reverse_type_mapping: {typeName → (model, UUID)}
-    ↓ 对每个物料:
-       typeName → 查映射 → model (如 "BIOYOND_PolymerStation_Reactor")
-       initialize_resource({"name": unique_name, "class": model})
-    ↓ 设置 unilabos_extra (material_bioyond_id, material_bioyond_name 等)
-    ↓ 处理 detail (子物料/坐标)
-    ↓ 按 locationName 放入 deck.warehouses 对应槽位
-PLR 资源列表
-```
-
-### `resource_plr_to_bioyond` 流程
-
-```
-PLR 资源列表
-    ↓ 遍历每个资源:
-       载架(capacity > 1): 生成 details 子物料 + 坐标
-       单瓶: 直接映射
-    ↓ type_mapping 查找 typeId
-    ↓ warehouse_mapping 查找位置 UUID
-    ↓ 组装 Bioyond 格式 (name, typeName, typeId, quantity, Parameters, locations)
-Bioyond 物料列表
-```
-
-### BioyondResourceSynchronizer
-
-工作站通过 `ResourceSynchronizer` 自动同步物料：
-
-```python
-class BioyondResourceSynchronizer(ResourceSynchronizer):
-    def sync_from_external(self) -> bool:
-        all_data = []
-        all_data.extend(api_client.stock_material('{"typeMode": 0}'))  # 耗材
-        all_data.extend(api_client.stock_material('{"typeMode": 1}'))  # 样品
-        all_data.extend(api_client.stock_material('{"typeMode": 2}'))  # 试剂
-        unilab_resources = resource_bioyond_to_plr(
-            all_data,
-            type_mapping=self.workstation.bioyond_config["material_type_mappings"],
-            deck=self.workstation.deck
-        )
-        # 更新 deck 上的资源
-```
-
----
-
-## 4. 非瓶类资源
-
-### ElectrodeSheet（极片）
-
-路径：`unilabos/resources/battery/electrode_sheet.py`
-
-```python
-class ElectrodeSheet(ResourcePLR):
-    """片状材料（极片、隔膜、弹片、垫片等）"""
-    _unilabos_state = {
-        "diameter": 0.0,
-        "thickness": 0.0,
-        "mass": 0.0,
-        "material_type": "",
-        "color": "",
-        "info": "",
-    }
-```
-
-工厂函数：`PositiveCan`, `PositiveElectrode`, `NegativeCan`, `NegativeElectrode`, `SpringWasher`, `FlatWasher`, `AluminumFoil`
-
-### Battery（电池）
-
-```python
-class Battery(Container):
-    """组装好的电池"""
-    _unilabos_state = {
-        "color": "",
-        "electrolyte_name": "",
-        "open_circuit_voltage": 0.0,
-    }
-```
-
-### Magazine / MagazineHolder（子弹夹）
-
-```python
-class Magazine(ResourceStack):
-    """子弹夹洞位，可堆叠 ElectrodeSheet"""
-    # direction, max_sheets
-
-class MagazineHolder(ItemizedResource):
-    """多洞位子弹夹"""
-    # hole_diameter, hole_depth, max_sheets_per_hole
-```
-
-工厂函数 `magazine_factory()` 用 `create_homogeneous_resources` 生成洞位，可选预填 `ElectrodeSheet` 或 `Battery`。
-
----
-
-## 5. 仓库工厂模式参考
-
-### 实际 warehouse 工厂函数示例
-
-```python
-# 行优先 4x4 仓库
-def bioyond_warehouse_1x4x4(name: str) -> WareHouse:
-    return warehouse_factory(
-        name=name,
-        num_items_x=4, num_items_y=4, num_items_z=1,
-        dx=10.0, dy=10.0, dz=10.0,
-        item_dx=147.0, item_dy=106.0, item_dz=130.0,
-        layout="row-major",  # A01,A02,A03,A04, B01,...
-    )
-
-# 右侧 4x4 仓库（列名偏移）
-def bioyond_warehouse_1x4x4_right(name: str) -> WareHouse:
-    return warehouse_factory(
-        name=name,
-        num_items_x=4, num_items_y=4, num_items_z=1,
-        dx=10.0, dy=10.0, dz=10.0,
-        item_dx=147.0, item_dy=106.0, item_dz=130.0,
-        col_offset=4,      # A05,A06,A07,A08
-        layout="row-major",
-    )
-
-# 竖向仓库（站内试剂存放）
-def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
-    return warehouse_factory(
-        name=name,
-        num_items_x=1, num_items_y=2, num_items_z=1,
-        dx=10.0, dy=10.0, dz=10.0,
-        item_dx=147.0, item_dy=106.0, item_dz=130.0,
-        layout="vertical-col-major",
-    )
-
-# 行偏移（F 行开始）
-def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse:
-    return warehouse_factory(
-        name=name,
-        num_items_x=3, num_items_y=5, num_items_z=1,
-        dx=10.0, dy=10.0, dz=10.0,
-        item_dx=159.0, item_dy=183.0, item_dz=130.0,
-        row_offset=row_offset,  # 0→A行起，5→F行起
-        layout="row-major",
-    )
-```
-
-### layout 类型说明
-
-| layout | 命名顺序 | 适用场景 |
-|--------|---------|---------|
-| `col-major` (默认) | A01,B01,C01,D01, A02,B02,... | 列优先，标准堆栈 |
-| `row-major` | A01,A02,A03,A04, B01,B02,... | 行优先，Bioyond 前端展示 |
-| `vertical-col-major` | 竖向排列，标签从底部开始 | 竖向仓库（试剂存放、测密度） |
-
----
-
-## 6. 关键路径
-
-| 内容 | 路径 |
-|------|------|
-| Bottle/Carrier 基类 | `unilabos/resources/itemized_carrier.py` |
-| WareHouse 类 + 工厂 | `unilabos/resources/warehouse.py` |
-| ResourceTreeSet 转换 | `unilabos/resources/resource_tracker.py` |
-| Bioyond 物料转换 | `unilabos/resources/graphio.py` |
-| Bioyond 仓库定义 | `unilabos/resources/bioyond/warehouses.py` |
-| 电池资源 | `unilabos/resources/battery/` |
-| PLR 注册 | `unilabos/resources/plr_additional_res_reg.py` |

.cursor/skills/add-workstation/SKILL.md

@@ -1,626 +0,0 @@
----
-name: add-workstation
-description: Guide for adding new workstations to Uni-Lab-OS (接入新工作站). Uses @device decorator + AST auto-scanning. Walks through workstation type, sub-device composition, driver creation, deck setup, and graph file. Use when the user wants to add a workstation, create a workstation driver, configure a station with sub-devices, or mentions 工作站/工站/station/workstation.
----
-
-# Uni-Lab-OS 工作站接入指南
-
-工作站（workstation）是组合多个子设备的大型设备，拥有独立的物料管理系统和工作流引擎。使用 `@device` 装饰器注册，AST 自动扫描生成注册表。
-
----
-
-## 工作站类型
-
-| 类型                | 基类              | 适用场景                           |
-| ------------------- | ----------------- | ---------------------------------- |
-| **Protocol 工作站** | `ProtocolNode`    | 标准化学操作协议（泵转移、过滤等） |
-| **外部系统工作站**  | `WorkstationBase` | 与外部 LIMS/MES 对接               |
-| **硬件控制工作站**  | `WorkstationBase` | 直接控制 PLC/硬件                  |
-
----
-
-## @device 装饰器（工作站）
-
-工作站也使用 `@device` 装饰器注册，参数与普通设备一致：
-
-```python
-@device(
-    id="my_workstation",           # 注册表唯一标识（必填）
-    category=["workstation"],      # 分类标签
-    description="我的工作站",
-)
-```
-
-如果一个工作站类支持多个具体变体，可使用 `ids` / `id_meta`，与设备的用法相同（参见 add-device SKILL）。
-
----
-
-## 工作站驱动模板
-
-### 模板 A：基于外部系统的工作站
-
-```python
-import logging
-from typing import Dict, Any, Optional
-from pylabrobot.resources import Deck
-
-from unilabos.registry.decorators import device, topic_config, not_action
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-
-try:
-    from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
-except ImportError:
-    ROS2WorkstationNode = None
-
-
-@device(id="my_workstation", category=["workstation"], description="我的工作站")
-class MyWorkstation(WorkstationBase):
-    _ros_node: "ROS2WorkstationNode"
-
-    def __init__(self, config=None, deck=None, protocol_type=None, **kwargs):
-        super().__init__(deck=deck, **kwargs)
-        self.config = config or {}
-        self.logger = logging.getLogger("MyWorkstation")
-        self.api_host = self.config.get("api_host", "")
-        self._status = "Idle"
-
-    @not_action
-    def post_init(self, ros_node: "ROS2WorkstationNode"):
-        super().post_init(ros_node)
-        self._ros_node = ros_node
-
-    async def scheduler_start(self, **kwargs) -> Dict[str, Any]:
-        """注册为工作站动作"""
-        return {"success": True}
-
-    async def create_order(self, json_str: str, **kwargs) -> Dict[str, Any]:
-        """注册为工作站动作"""
-        return {"success": True}
-
-    @property
-    @topic_config()
-    def workflow_sequence(self) -> str:
-        return "[]"
-
-    @property
-    @topic_config()
-    def material_info(self) -> str:
-        return "{}"
-```
-
-### 模板 B：Protocol 工作站
-
-直接使用 `ProtocolNode`，通常不需要自定义驱动类：
-
-```python
-from unilabos.devices.workstation.workstation_base import ProtocolNode
-```
-
-在图文件中配置 `protocol_type` 即可。
-
----
-
-## 子设备访问（sub_devices）
-
-工站初始化子设备后，所有子设备实例存储在 `self._ros_node.sub_devices` 字典中（key 为设备 id，value 为 `ROS2DeviceNode` 实例）。工站的驱动类可以直接获取子设备实例来调用其方法：
-
-```python
-# 在工站驱动类的方法中访问子设备
-sub = self._ros_node.sub_devices["pump_1"]
-
-# .driver_instance — 子设备的驱动实例（即设备 Python 类的实例）
-sub.driver_instance.some_method(arg1, arg2)
-
-# .ros_node_instance — 子设备的 ROS2 节点实例
-sub.ros_node_instance._action_value_mappings  # 查看子设备支持的 action
-```
-
-**常见用法**：
-
-```python
-class MyWorkstation(WorkstationBase):
-    def my_protocol(self, **kwargs):
-        # 获取子设备驱动实例
-        pump = self._ros_node.sub_devices["pump_1"].driver_instance
-        heater = self._ros_node.sub_devices["heater_1"].driver_instance
-
-        # 直接调用子设备方法
-        pump.aspirate(volume=100)
-        heater.set_temperature(80)
-```
-
-> 参考实现：`unilabos/devices/workstation/bioyond_studio/reaction_station/reaction_station.py` 中通过 `self._ros_node.sub_devices.get(reactor_id)` 获取子反应器实例并更新数据。
-
----
-
-## 硬件通信接口（hardware_interface）
-
-硬件控制型工作站通常需要通过串口（Serial）、Modbus 等通信协议控制多个子设备。Uni-Lab-OS 通过 **通信设备代理** 机制实现端口共享：一个串口只创建一个 `serial` 节点，多个子设备共享这个通信实例。
-
-### 工作原理
-
-`ROS2WorkstationNode` 初始化时分两轮遍历子设备（`workstation.py`）：
-
-**第一轮 — 初始化所有子设备**：按 `children` 顺序调用 `initialize_device()`，通信设备（`serial_` / `io_` 开头的 id）优先完成初始化，创建 `serial.Serial()` 实例。其他子设备此时 `self.hardware_interface = "serial_pump"`（字符串）。
-
-**第二轮 — 代理替换**：遍历所有已初始化的子设备，读取子设备的 `_hardware_interface` 配置：
-
-```
-hardware_interface = d.ros_node_instance._hardware_interface
-# → {"name": "hardware_interface", "read": "send_command", "write": "send_command"}
-```
-
-1. 取 `name` 字段对应的属性值：`name_value = getattr(driver, hardware_interface["name"])`
-   - 如果 `name_value` 是字符串且该字符串是某个子设备的 id → 触发代理替换
-2. 从通信设备获取真正的 `read`/`write` 方法
-3. 用 `setattr(driver, read_method, _read)` 将通信设备的方法绑定到子设备上
-
-因此：
-
-- **通信设备 id 必须与子设备 config 中填的字符串完全一致**（如 `"serial_pump"`）
-- **通信设备 id 必须以 `serial_` 或 `io_` 开头**（否则第一轮不会被识别为通信设备）
-- **通信设备必须在 `children` 列表中排在最前面**，确保先初始化
-
-### HardwareInterface 参数说明
-
-```python
-from unilabos.registry.decorators import HardwareInterface
-
-HardwareInterface(
-    name="hardware_interface",   # __init__ 中接收通信实例的属性名
-    read="send_command",         # 通信设备上暴露的读方法名
-    write="send_command",        # 通信设备上暴露的写方法名
-    extra_info=["list_ports"],   # 可选：额外暴露的方法
-)
-```
-
-**`name` 字段的含义**：对应设备类 `__init__` 中，用于保存通信实例的**属性名**。系统据此知道要替换哪个属性。大部分设备直接用 `"hardware_interface"`，也可以自定义（如 `"io_device_port"`）。
-
-### 示例 1：泵（name="hardware_interface"）
-
-```python
-from unilabos.registry.decorators import device, HardwareInterface
-
-@device(
-    id="my_pump",
-    category=["pump_and_valve"],
-    hardware_interface=HardwareInterface(
-        name="hardware_interface",
-        read="send_command",
-        write="send_command",
-    ),
-)
-class MyPump:
-    def __init__(self, port=None, address="1", **kwargs):
-        # name="hardware_interface" → 系统替换 self.hardware_interface
-        self.hardware_interface = port  # 初始为字符串 "serial_pump"，启动后被替换为 Serial 实例
-        self.address = address
-
-    def send_command(self, command: str):
-        full_command = f"/{self.address}{command}\r\n"
-        self.hardware_interface.write(bytearray(full_command, "ascii"))
-        return self.hardware_interface.read_until(b"\n")
-```
-
-### 示例 2：电磁阀（name="io_device_port"，自定义属性名）
-
-```python
-@device(
-    id="solenoid_valve",
-    category=["pump_and_valve"],
-    hardware_interface=HardwareInterface(
-        name="io_device_port",       # 自定义属性名 → 系统替换 self.io_device_port
-        read="read_io_coil",
-        write="write_io_coil",
-    ),
-)
-class SolenoidValve:
-    def __init__(self, io_device_port: str = None, **kwargs):
-        # name="io_device_port" → 图文件 config 中用 "io_device_port": "io_board_1"
-        self.io_device_port = io_device_port  # 初始为字符串，系统替换为 Modbus 实例
-```
-
-### Serial 通信设备（class="serial"）
-
-`serial` 是 Uni-Lab-OS 内置的通信代理设备，代码位于 `unilabos/ros/nodes/presets/serial_node.py`：
-
-```python
-from serial import Serial, SerialException
-from threading import Lock
-
-class ROS2SerialNode(BaseROS2DeviceNode):
-    def __init__(self, device_id, registry_name, port: str, baudrate: int = 9600, **kwargs):
-        self.port = port
-        self.baudrate = baudrate
-        self._hardware_interface = {
-            "name": "hardware_interface",
-            "write": "send_command",
-            "read": "read_data",
-        }
-        self._query_lock = Lock()
-
-        self.hardware_interface = Serial(baudrate=baudrate, port=port)
-
-        BaseROS2DeviceNode.__init__(
-            self, driver_instance=self, registry_name=registry_name,
-            device_id=device_id, status_types={}, action_value_mappings={},
-            hardware_interface=self._hardware_interface, print_publish=False,
-        )
-        self.create_service(SerialCommand, "serialwrite", self.handle_serial_request)
-
-    def send_command(self, command: str):
-        with self._query_lock:
-            self.hardware_interface.write(bytearray(f"{command}\n", "ascii"))
-            return self.hardware_interface.read_until(b"\n").decode()
-
-    def read_data(self):
-        with self._query_lock:
-            return self.hardware_interface.read_until(b"\n").decode()
-```
-
-在图文件中使用 `"class": "serial"` 即可创建串口代理：
-
-```json
-{
-  "id": "serial_pump",
-  "class": "serial",
-  "parent": "my_station",
-  "config": { "port": "COM7", "baudrate": 9600 }
-}
-```
-
-### 图文件配置
-
-**通信设备必须在 `children` 列表中排在最前面**，确保先于其他子设备初始化：
-
-```json
-{
-  "nodes": [
-    {
-      "id": "my_station",
-      "class": "workstation",
-      "children": ["serial_pump", "pump_1", "pump_2"],
-      "config": { "protocol_type": ["PumpTransferProtocol"] }
-    },
-    {
-      "id": "serial_pump",
-      "class": "serial",
-      "parent": "my_station",
-      "config": { "port": "COM7", "baudrate": 9600 }
-    },
-    {
-      "id": "pump_1",
-      "class": "syringe_pump_with_valve.runze.SY03B-T08",
-      "parent": "my_station",
-      "config": { "port": "serial_pump", "address": "1", "max_volume": 25.0 }
-    },
-    {
-      "id": "pump_2",
-      "class": "syringe_pump_with_valve.runze.SY03B-T08",
-      "parent": "my_station",
-      "config": { "port": "serial_pump", "address": "2", "max_volume": 25.0 }
-    }
-  ],
-  "links": [
-    {
-      "source": "pump_1",
-      "target": "serial_pump",
-      "type": "communication",
-      "port": { "pump_1": "port", "serial_pump": "port" }
-    },
-    {
-      "source": "pump_2",
-      "target": "serial_pump",
-      "type": "communication",
-      "port": { "pump_2": "port", "serial_pump": "port" }
-    }
-  ]
-}
-```
-
-### 通信协议速查
-
-| 协议                 | config 参数                    | 依赖包     | 通信设备 class             |
-| -------------------- | ------------------------------ | ---------- | -------------------------- |
-| Serial (RS232/RS485) | `port`, `baudrate`             | `pyserial` | `serial`                   |
-| Modbus RTU           | `port`, `baudrate`, `slave_id` | `pymodbus` | `device_comms/modbus_plc/` |
-| Modbus TCP           | `host`, `port`, `slave_id`     | `pymodbus` | `device_comms/modbus_plc/` |
-| TCP Socket           | `host`, `port`                 | stdlib     | 自定义                     |
-| HTTP API             | `url`, `token`                 | `requests` | `device_comms/rpc.py`      |
-
-参考实现：`unilabos/test/experiments/Grignard_flow_batchreact_single_pumpvalve.json`
-
----
-
-## Deck 与物料生命周期
-
-### 1. Deck 入参与两种初始化模式
-
-系统根据设备节点 `config.deck` 的写法，自动反序列化 Deck 实例后传入 `__init__` 的 `deck` 参数。目前 `deck` 是固定字段名，只支持一个主 Deck。建议一个设备拥有一个台面，台面上抽象二级、三级子物料。
-
-有两种初始化模式：
-
-#### init 初始化（推荐）
-
-`config.deck` 直接包含 `_resource_type` + `_resource_child_name`，系统先用 Deck 节点的 `config` 调用 Deck 类的 `__init__` 反序列化，再将实例传入设备的 `deck` 参数。子物料随 Deck 的 `children` 一起反序列化。
-
-```json
-"config": {
-    "deck": {
-        "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
-        "_resource_child_name": "PRCXI_Deck"
-    }
-}
-```
-
-#### deserialize 初始化
-
-`config.deck` 用 `data` 包裹一层，系统走 `deserialize` 路径，可传入更多参数（如 `allow_marshal` 等）：
-
-```json
-"config": {
-    "deck": {
-        "data": {
-            "_resource_child_name": "YB_Bioyond_Deck",
-            "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
-        }
-    }
-}
-```
-
-没有特殊需求时推荐 init 初始化。
-
-#### config.deck 字段说明
-
-| 字段 | 说明 |
-|------|------|
-| `_resource_type` | Deck 类的完整模块路径（`module:ClassName`） |
-| `_resource_child_name` | 对应图文件中 Deck 节点的 `id`，建立父子关联 |
-
-#### 设备 __init__ 接收
-
-```python
-def __init__(self, config=None, deck=None, protocol_type=None, **kwargs):
-    super().__init__(deck=deck, **kwargs)
-    # deck 已经是反序列化后的 Deck 实例
-    # → PRCXI9300Deck / BIOYOND_YB_Deck 等
-```
-
-#### Deck 节点（图文件中）
-
-Deck 节点作为设备的 `children` 之一，`parent` 指向设备 id：
-
-```json
-{
-    "id": "PRCXI_Deck",
-    "parent": "PRCXI",
-    "type": "deck",
-    "class": "",
-    "children": [],
-    "config": {
-        "type": "PRCXI9300Deck",
-        "size_x": 542, "size_y": 374, "size_z": 0,
-        "category": "deck",
-        "sites": [...]
-    },
-    "data": {}
-}
-```
-
-- `config` 中的字段会传入 Deck 类的 `__init__`（因此 `__init__` 必须能接受所有 `serialize()` 输出的字段）
-- `children` 初始为空时，由同步器或手动初始化填充
-- `config.type` 填 Deck 类名
-
-### 2. Deck 为空时自行初始化
-
-如果 Deck 节点的 `children` 为空，工作站需在 `post_init` 或首次同步时自行初始化内容：
-
-```python
-@not_action
-def post_init(self, ros_node):
-    super().post_init(ros_node)
-    if self.deck and not self.deck.children:
-        self._initialize_default_deck()
-
-def _initialize_default_deck(self):
-    from my_labware import My_TipRack, My_Plate
-    self.deck.assign_child_resource(My_TipRack("T1"), spot=0)
-    self.deck.assign_child_resource(My_Plate("T2"), spot=1)
-```
-
-### 3. 物料双向同步
-
-当工作站对接外部系统（LIMS/MES）时，需要实现 `ResourceSynchronizer` 处理双向物料同步：
-
-```python
-from unilabos.devices.workstation.workstation_base import ResourceSynchronizer
-
-class MyResourceSynchronizer(ResourceSynchronizer):
-    def sync_from_external(self) -> bool:
-        """从外部系统同步到 self.workstation.deck"""
-        external_data = self._query_external_materials()
-        # 以外部工站为准：根据外部数据反向创建 PLR 资源实例
-        for item in external_data:
-            cls = self._resolve_resource_class(item["type"])
-            resource = cls(name=item["name"], **item["params"])
-            self.workstation.deck.assign_child_resource(resource, spot=item["slot"])
-        return True
-
-    def sync_to_external(self, resource) -> bool:
-        """将 UniLab 侧物料变更同步到外部系统"""
-        # 以 UniLab 为准：将 PLR 资源转为外部格式并推送
-        external_format = self._convert_to_external(resource)
-        return self._push_to_external(external_format)
-
-    def handle_external_change(self, change_info) -> bool:
-        """处理外部系统主动推送的变更"""
-        return True
-```
-
-同步策略取决于业务场景：
-
-- **以外部工站为准**：从外部 API 查询物料数据，反向创建对应的 PLR 资源实例放到 Deck 上
-- **以 UniLab 为准**：UniLab 侧的物料变更通过 `sync_to_external` 推送到外部系统
-
-在工作站 `post_init` 中初始化同步器：
-
-```python
-@not_action
-def post_init(self, ros_node):
-    super().post_init(ros_node)
-    self.resource_synchronizer = MyResourceSynchronizer(self)
-    self.resource_synchronizer.sync_from_external()
-```
-
-### 4. 序列化与持久化（serialize / serialize_state）
-
-资源类需正确实现序列化，系统据此完成持久化和前端同步。
-
-**`serialize()`** — 输出资源的结构信息（`config` 层），反序列化时作为 `__init__` 的入参回传。因此 **`__init__` 必须通过 `**kwargs`接受`serialize()` 输出的所有字段\*\*，即使当前不使用：
-
-```python
-class MyDeck(Deck):
-    def __init__(self, name, size_x, size_y, size_z,
-                 sites=None,          # serialize() 输出的字段
-                 rotation=None,       # serialize() 输出的字段
-                 barcode=None,        # serialize() 输出的字段
-                 **kwargs):           # 兜底：接受所有未知的 serialize 字段
-        super().__init__(size_x, size_y, size_z, name)
-        # ...
-
-    def serialize(self) -> dict:
-        data = super().serialize()
-        data["sites"] = [...]  # 自定义字段
-        return data
-```
-
-**`serialize_state()`** — 输出资源的运行时状态（`data` 层），用于持久化可变信息。`data` 中的内容会被正确保存和恢复：
-
-```python
-class MyPlate(Plate):
-    def __init__(self, name, size_x, size_y, size_z,
-                 material_info=None, **kwargs):
-        super().__init__(name, size_x, size_y, size_z, **kwargs)
-        self._unilabos_state = {}
-        if material_info:
-            self._unilabos_state["Material"] = material_info
-
-    def serialize_state(self) -> Dict[str, Any]:
-        data = super().serialize_state()
-        data.update(self._unilabos_state)
-        return data
-```
-
-关键要点：
-
-- `serialize()` 输出的所有字段都会作为 `config` 回传到 `__init__`，所以 `__init__` 必须能接受它们（显式声明或 `**kwargs`）
-- `serialize_state()` 输出的 `data` 用于持久化运行时状态（如物料信息、液体量等）
-- `_unilabos_state` 中只存可 JSON 序列化的基本类型（str, int, float, bool, list, dict, None）
-
-### 5. 子物料自动同步
-
-子物料（Bottle、Plate、TipRack 等）放到 Deck 上后，系统会自动将其同步到前端的 Deck 视图。只需保证资源类正确实现了 `serialize()` / `serialize_state()` 和反序列化即可。
-
-### 6. 图文件配置（参考 prcxi_9320_slim.json）
-
-```json
-{
-  "nodes": [
-    {
-      "id": "my_station",
-      "type": "device",
-      "class": "my_workstation",
-      "config": {
-        "deck": {
-          "_resource_type": "unilabos.resources.my_module:MyDeck",
-          "_resource_child_name": "my_deck"
-        },
-        "host": "10.20.30.1",
-        "port": 9999
-      }
-    },
-    {
-      "id": "my_deck",
-      "parent": "my_station",
-      "type": "deck",
-      "class": "",
-      "children": [],
-      "config": {
-        "type": "MyLabDeck",
-        "size_x": 542,
-        "size_y": 374,
-        "size_z": 0,
-        "category": "deck",
-        "sites": [
-          {
-            "label": "T1",
-            "visible": true,
-            "occupied_by": null,
-            "position": { "x": 0, "y": 0, "z": 0 },
-            "size": { "width": 128.0, "height": 86, "depth": 0 },
-            "content_type": ["plate", "tip_rack", "tube_rack", "adaptor"]
-          }
-        ]
-      },
-      "data": {}
-    }
-  ],
-  "edges": []
-}
-```
-
-Deck 节点要点：
-
-- `config.type` 填 Deck 类名（如 `"PRCXI9300Deck"`）
-- `config.sites` 完整列出所有 site（从 Deck 类的 `serialize()` 输出获取）
-- `children` 初始为空（由同步器或手动初始化填充）
-- 设备节点 `config.deck._resource_type` 指向 Deck 类的完整模块路径
-
----
-
-## 子设备
-
-子设备按标准设备接入流程创建（参见 add-device SKILL），使用 `@device` 装饰器。
-
-子设备约束：
-
-- 图文件中 `parent` 指向工作站 ID
-- 在工作站 `children` 数组中列出
-
----
-
-## 关键规则
-
-1. **`__init__` 必须接受 `deck` 和 `**kwargs`** — `WorkstationBase.**init**`需要`deck` 参数
-2. **Deck 通过 `config.deck._resource_type` 反序列化传入** — 不要在 `__init__` 中手动创建 Deck
-3. **Deck 为空时自行初始化内容** — 在 `post_init` 中检查并填充默认物料
-4. **外部同步实现 `ResourceSynchronizer`** — `sync_from_external` / `sync_to_external`
-5. **通过 `self._children` 访问子设备** — 不要自行维护子设备引用
-6. **`post_init` 中启动后台服务** — 不要在 `__init__` 中启动网络连接
-7. **异步方法使用 `await self._ros_node.sleep()`** — 禁止 `time.sleep()` 和 `asyncio.sleep()`
-8. **使用 `@not_action` 标记非动作方法** — `post_init`, `initialize`, `cleanup`
-9. **子物料保证正确 serialize/deserialize** — 系统自动同步到前端 Deck 视图
-
----
-
-## 验证
-
-```bash
-# 模块可导入
-python -c "from unilabos.devices.workstation.<name>.<name> import <ClassName>"
-
-# 启动测试（AST 自动扫描）
-unilab -g <graph>.json
-```
-
----
-
-## 现有工作站参考
-
-| 工作站         | 驱动类                        | 类型     |
-| -------------- | ----------------------------- | -------- |
-| Protocol 通用  | `ProtocolNode`                | Protocol |
-| Bioyond 反应站 | `BioyondReactionStation`      | 外部系统 |
-| 纽扣电池组装   | `CoinCellAssemblyWorkstation` | 硬件控制 |
-
-参考路径：`unilabos/devices/workstation/` 目录下各工作站实现。

.cursor/skills/add-workstation/reference.md

@@ -1,371 +0,0 @@
-# 工作站高级模式参考
-
-本文件是 SKILL.md 的补充，包含外部系统集成、物料同步、配置结构等高级模式。
-Agent 在需要实现这些功能时按需阅读。
-
----
-
-## 1. 外部系统集成模式
-
-### 1.1 RPC 客户端
-
-与外部 LIMS/MES 系统通信的标准模式。继承 `BaseRequest`，所有接口统一用 POST。
-
-```python
-from unilabos.device_comms.rpc import BaseRequest
-
-
-class MySystemRPC(BaseRequest):
-    """外部系统 RPC 客户端"""
-
-    def __init__(self, host: str, api_key: str):
-        super().__init__(host)
-        self.api_key = api_key
-
-    def _request(self, endpoint: str, data: dict = None) -> dict:
-        return self.post(
-            url=f"{self.host}/api/{endpoint}",
-            params={
-                "apiKey": self.api_key,
-                "requestTime": self.get_current_time_iso8601(),
-                "data": data or {},
-            },
-        )
-
-    def query_status(self) -> dict:
-        return self._request("status/query")
-
-    def create_order(self, order_data: dict) -> dict:
-        return self._request("order/create", order_data)
-```
-
-参考：`unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py`（`BioyondV1RPC`）
-
-### 1.2 HTTP 回调服务
-
-接收外部系统报送的标准模式。使用 `WorkstationHTTPService`，在 `post_init` 中启动。
-
-```python
-from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
-
-
-class MyWorkstation(WorkstationBase):
-    def __init__(self, config=None, deck=None, **kwargs):
-        super().__init__(deck=deck, **kwargs)
-        self.config = config or {}
-        http_cfg = self.config.get("http_service_config", {})
-        self._http_service_config = {
-            "host": http_cfg.get("http_service_host", "127.0.0.1"),
-            "port": http_cfg.get("http_service_port", 8080),
-        }
-        self.http_service = None
-
-    def post_init(self, ros_node):
-        super().post_init(ros_node)
-        self.http_service = WorkstationHTTPService(
-            workstation_instance=self,
-            host=self._http_service_config["host"],
-            port=self._http_service_config["port"],
-        )
-        self.http_service.start()
-```
-
-**HTTP 服务路由**（固定端点，由 `WorkstationHTTPHandler` 自动分发）：
-
-| 端点 | 调用的工作站方法 |
-|------|-----------------|
-| `/report/step_finish` | `process_step_finish_report(report_request)` |
-| `/report/sample_finish` | `process_sample_finish_report(report_request)` |
-| `/report/order_finish` | `process_order_finish_report(report_request, used_materials)` |
-| `/report/material_change` | `process_material_change_report(report_data)` |
-| `/report/error_handling` | `handle_external_error(error_data)` |
-
-实现对应方法即可接收回调：
-
-```python
-def process_step_finish_report(self, report_request) -> Dict[str, Any]:
-    """处理步骤完成报告"""
-    step_name = report_request.data.get("stepName")
-    return {"success": True, "message": f"步骤 {step_name} 已处理"}
-
-def process_order_finish_report(self, report_request, used_materials) -> Dict[str, Any]:
-    """处理订单完成报告"""
-    order_code = report_request.data.get("orderCode")
-    return {"success": True}
-```
-
-参考：`unilabos/devices/workstation/workstation_http_service.py`
-
-### 1.3 连接监控
-
-独立线程周期性检测外部系统连接状态，状态变化时发布 ROS 事件。
-
-```python
-class ConnectionMonitor:
-    def __init__(self, workstation, check_interval=30):
-        self.workstation = workstation
-        self.check_interval = check_interval
-        self._running = False
-        self._thread = None
-
-    def start(self):
-        self._running = True
-        self._thread = threading.Thread(target=self._monitor_loop, daemon=True)
-        self._thread.start()
-
-    def _monitor_loop(self):
-        while self._running:
-            try:
-                # 调用外部系统接口检测连接
-                self.workstation.hardware_interface.ping()
-                status = "online"
-            except Exception:
-                status = "offline"
-            time.sleep(self.check_interval)
-```
-
-参考：`unilabos/devices/workstation/bioyond_studio/station.py`（`ConnectionMonitor`）
-
----
-
-## 2. Config 结构模式
-
-工作站的 `config` 在图文件中定义，传入 `__init__`。以下是常见字段模式：
-
-### 2.1 外部系统连接
-
-```json
-{
-    "api_host": "http://192.168.1.100:8080",
-    "api_key": "YOUR_API_KEY"
-}
-```
-
-### 2.2 HTTP 回调服务
-
-```json
-{
-    "http_service_config": {
-        "http_service_host": "127.0.0.1",
-        "http_service_port": 8080
-    }
-}
-```
-
-### 2.3 物料类型映射
-
-将 PLR 资源类名映射到外部系统的物料类型（名称 + UUID）。用于双向物料转换。
-
-```json
-{
-    "material_type_mappings": {
-        "PLR_ResourceClassName": ["外部系统显示名", "external-type-uuid"],
-        "BIOYOND_PolymerStation_Reactor": ["反应器", "3a14233b-902d-0d7b-..."]
-    }
-}
-```
-
-### 2.4 仓库映射
-
-将仓库名映射到外部系统的仓库 UUID 和库位 UUID。用于入库/出库操作。
-
-```json
-{
-    "warehouse_mapping": {
-        "仓库名": {
-            "uuid": "warehouse-uuid",
-            "site_uuids": {
-                "A01": "site-uuid-A01",
-                "A02": "site-uuid-A02"
-            }
-        }
-    }
-}
-```
-
-### 2.5 工作流映射
-
-将内部工作流名映射到外部系统的工作流 ID。
-
-```json
-{
-    "workflow_mappings": {
-        "internal_workflow_name": "external-workflow-uuid"
-    }
-}
-```
-
-### 2.6 物料默认参数
-
-```json
-{
-    "material_default_parameters": {
-        "NMP": {
-            "unit": "毫升",
-            "density": "1.03",
-            "densityUnit": "g/mL",
-            "description": "N-甲基吡咯烷酮"
-        }
-    }
-}
-```
-
----
-
-## 3. 资源同步机制
-
-### 3.1 ResourceSynchronizer
-
-抽象基类，用于与外部物料系统双向同步。定义在 `workstation_base.py`。
-
-```python
-from unilabos.devices.workstation.workstation_base import ResourceSynchronizer
-
-
-class MyResourceSynchronizer(ResourceSynchronizer):
-    def __init__(self, workstation, api_client):
-        super().__init__(workstation)
-        self.api_client = api_client
-
-    def sync_from_external(self) -> bool:
-        """从外部系统拉取物料到 deck"""
-        external_materials = self.api_client.list_materials()
-        for material in external_materials:
-            plr_resource = self._convert_to_plr(material)
-            self.workstation.deck.assign_child_resource(plr_resource, coordinate)
-        return True
-
-    def sync_to_external(self, plr_resource) -> bool:
-        """将 deck 中的物料变更推送到外部系统"""
-        external_data = self._convert_from_plr(plr_resource)
-        self.api_client.update_material(external_data)
-        return True
-
-    def handle_external_change(self, change_info) -> bool:
-        """处理外部系统推送的物料变更"""
-        return True
-```
-
-### 3.2 update_resource — 上传资源树到云端
-
-将 PLR Deck 序列化后通过 ROS 服务上传。典型使用场景：
-
-```python
-# 在 post_init 中上传初始 deck
-from unilabos.ros.nodes.base_device_node import ROS2DeviceNode
-
-ROS2DeviceNode.run_async_func(
-    self._ros_node.update_resource, True,
-    **{"resources": [self.deck]}
-)
-
-# 在动作方法中更新特定资源
-ROS2DeviceNode.run_async_func(
-    self._ros_node.update_resource, True,
-    **{"resources": [updated_plate]}
-)
-```
-
----
-
-## 4. 工作流序列管理
-
-工作站通过 `workflow_sequence` 属性管理任务队列（JSON 字符串形式）。
-
-```python
-class MyWorkstation(WorkstationBase):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._workflow_sequence = []
-
-    @property
-    def workflow_sequence(self) -> str:
-        """返回 JSON 字符串，ROS 自动发布"""
-        import json
-        return json.dumps(self._workflow_sequence)
-
-    async def append_to_workflow_sequence(self, workflow_name: str) -> Dict[str, Any]:
-        """添加工作流到队列"""
-        self._workflow_sequence.append({
-            "name": workflow_name,
-            "status": "pending",
-            "created_at": time.time(),
-        })
-        return {"success": True}
-
-    async def clear_workflows(self) -> Dict[str, Any]:
-        """清空工作流队列"""
-        self._workflow_sequence = []
-        return {"success": True}
-```
-
----
-
-## 5. 站间物料转移
-
-工作站之间转移物料的模式。通过 ROS ActionClient 调用目标站的动作。
-
-```python
-async def transfer_materials_to_another_station(
-    self,
-    target_device_id: str,
-    transfer_groups: list,
-    **kwargs,
-) -> Dict[str, Any]:
-    """将物料转移到另一个工作站"""
-    target_node = self._children.get(target_device_id)
-    if not target_node:
-        # 通过 ROS 节点查找非子设备的目标站
-        pass
-
-    for group in transfer_groups:
-        resource = self.find_resource_by_name(group["resource_name"])
-        # 从本站 deck 移除
-        resource.unassign()
-        # 调用目标站的接收方法
-        # ...
-
-    return {"success": True, "transferred": len(transfer_groups)}
-```
-
-参考：`BioyondDispensingStation.transfer_materials_to_reaction_station`
-
----
-
-## 6. post_init 完整模式
-
-`post_init` 是工作站初始化的关键阶段，此时 ROS 节点和子设备已就绪。
-
-```python
-def post_init(self, ros_node):
-    super().post_init(ros_node)
-
-    # 1. 初始化外部系统客户端（此时 config 已可用）
-    self.rpc_client = MySystemRPC(
-        host=self.config.get("api_host"),
-        api_key=self.config.get("api_key"),
-    )
-    self.hardware_interface = self.rpc_client
-
-    # 2. 启动连接监控
-    self.connection_monitor = ConnectionMonitor(self)
-    self.connection_monitor.start()
-
-    # 3. 启动 HTTP 回调服务
-    if hasattr(self, '_http_service_config'):
-        self.http_service = WorkstationHTTPService(
-            workstation_instance=self,
-            host=self._http_service_config["host"],
-            port=self._http_service_config["port"],
-        )
-        self.http_service.start()
-
-    # 4. 上传 deck 到云端
-    ROS2DeviceNode.run_async_func(
-        self._ros_node.update_resource, True,
-        **{"resources": [self.deck]}
-    )
-
-    # 5. 初始化资源同步器（可选）
-    self.resource_synchronizer = MyResourceSynchronizer(self, self.rpc_client)
-```

.cursor/skills/batch-insert-reagent/SKILL.md

@@ -1,261 +0,0 @@
----
-name: batch-insert-reagent
-description: Batch insert reagents into Uni-Lab platform — add chemicals with CAS, SMILES, supplier info. Use when the user wants to add reagents, insert chemicals, batch register reagents, or mentions 录入试剂/添加试剂/试剂入库/reagent.
----
-
-# 批量录入试剂 Skill
-
-通过云端 API 批量录入试剂信息，支持逐条或批量操作。
-
-## 前置条件（缺一不可）
-
-使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
-
-生成 AUTH token（任选一种方式）：
-
-```bash
-# 方式一：Python 一行生成
-python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
-
-# 方式二：手动计算
-# base64(ak:sk) → Authorization: Lab <token>
-```
-
-### 2. --addr → BASE URL
-
-| `--addr` 值  | BASE                                |
-| ------------ | ----------------------------------- |
-| `test`       | `https://leap-lab.test.bohrium.com` |
-| `uat`        | `https://leap-lab.uat.bohrium.com`  |
-| `local`      | `http://127.0.0.1:48197`            |
-| 不传（默认） | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-AUTH="Authorization: Lab <gen_auth.py 输出的 token>"
-```
-
-**两项全部就绪后才可发起 API 请求。**
-
-## Session State
-
-- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
-
-## 请求约定
-
-所有请求使用 `curl -s`，POST 需加 `Content-Type: application/json`。
-
-> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
-
----
-
-## API Endpoints
-
-### 1. 获取实验室信息（自动获取 lab_uuid）
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回：
-
-```json
-{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
-```
-
-记住 `data.uuid` 为 `lab_uuid`。
-
-### 2. 录入试剂
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/reagent" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{
-    "lab_uuid": "<lab_uuid>",
-    "cas": "<CAS号>",
-    "name": "<试剂名称>",
-    "molecular_formula": "<分子式>",
-    "smiles": "<SMILES>",
-    "stock_in_quantity": <入库数量>,
-    "unit": "<单位字符串>",
-    "supplier": "<供应商>",
-    "production_date": "<生产日期 ISO 8601>",
-    "expiry_date": "<过期日期 ISO 8601>"
-  }'
-```
-
-返回成功时包含试剂 UUID：
-
-```json
-{"code": 0, "data": {"uuid": "xxx", ...}}
-```
-
----
-
-## 试剂字段说明
-
-| 字段                | 类型   | 必填 | 说明                          | 示例                     |
-| ------------------- | ------ | ---- | ----------------------------- | ------------------------ |
-| `lab_uuid`          | string | 是   | 实验室 UUID（从 API #1 获取） | `"8511c672-..."`         |
-| `cas`               | string | 是   | CAS 注册号                    | `"7732-18-3"`            |
-| `name`              | string | 是   | 试剂中文/英文名称             | `"水"`                   |
-| `molecular_formula` | string | 是   | 分子式                        | `"H2O"`                  |
-| `smiles`            | string | 是   | SMILES 表示                   | `"O"`                    |
-| `stock_in_quantity` | number | 是   | 入库数量                      | `10`                     |
-| `unit`              | string | 是   | 单位（字符串，见下表）        | `"mL"`                   |
-| `supplier`          | string | 否   | 供应商名称                    | `"国药集团"`             |
-| `production_date`   | string | 否   | 生产日期（ISO 8601）          | `"2025-11-18T00:00:00Z"` |
-| `expiry_date`       | string | 否   | 过期日期（ISO 8601）          | `"2026-11-18T00:00:00Z"` |
-
-### unit 单位值
-
-| 值     | 单位 |
-| ------ | ---- |
-| `"mL"` | 毫升 |
-| `"L"`  | 升   |
-| `"g"`  | 克   |
-| `"kg"` | 千克 |
-| `"瓶"` | 瓶   |
-
-> 根据试剂状态选择：液体用 `"mL"` / `"L"`，固体用 `"g"` / `"kg"`。
-
----
-
-## 批量录入策略
-
-### 方式一：用户提供 JSON 数组
-
-用户一次性给出多条试剂数据：
-
-```json
-[
-  {
-    "cas": "7732-18-3",
-    "name": "水",
-    "molecular_formula": "H2O",
-    "smiles": "O",
-    "stock_in_quantity": 10,
-    "unit": "mL"
-  },
-  {
-    "cas": "64-17-5",
-    "name": "乙醇",
-    "molecular_formula": "C2H6O",
-    "smiles": "CCO",
-    "stock_in_quantity": 5,
-    "unit": "L"
-  }
-]
-```
-
-Agent 自动为每条补充 `lab_uuid`、`production_date`、`expiry_date` 等字段后逐条提交。
-
-Agent 循环调用 API #2 逐条录入，每条记录一次 API 调用。
-
-### 方式二：用户逐个描述
-
-用户口头描述试剂（如「帮我录入 500mL 的无水乙醇，Sigma 的」），agent 自行补全字段：
-
-1. 根据名称查找 CAS 号、分子式、SMILES（参考下方速查表或自行推断）
-2. 构建完整的请求体
-3. 向用户确认后提交
-
-### 方式三：从 CSV/表格批量导入
-
-用户提供 CSV 或表格文件路径，agent 读取并解析：
-
-```bash
-# 期望的 CSV 格式（首行为表头）
-cas,name,molecular_formula,smiles,stock_in_quantity,unit,supplier,production_date,expiry_date
-7732-18-3,水,H2O,O,10,mL,农夫山泉,2025-11-18T00:00:00Z,2026-11-18T00:00:00Z
-```
-
-### 日期格式规则（重要）
-
-所有日期字段（`production_date`、`expiry_date`）**必须**使用 ISO 8601 完整格式：`YYYY-MM-DDTHH:MM:SSZ`。
-
-- 用户输入 `2025-03-01` → 转换为 `"2025-03-01T00:00:00Z"`
-- 用户输入 `2025/9/1` → 转换为 `"2025-09-01T00:00:00Z"`
-- 用户未提供日期 → 使用当天日期 + `T00:00:00Z`，有效期默认 +1 年
-
-**禁止**发送不带时间部分的日期字符串（如 `"2025-03-01"`），API 会拒绝。
-
-### 执行与汇报
-
-每次 API 调用后：
-
-1. 检查返回 `code`（0 = 成功）
-2. 记录成功/失败数量
-3. 全部完成后汇总：「共录入 N 条试剂，成功 X 条，失败 Y 条」
-4. 如有失败，列出失败的试剂名称和错误信息
-
----
-
-## 常见试剂速查表
-
-| 名称                  | CAS       | 分子式     | SMILES                               |
-| --------------------- | --------- | ---------- | ------------------------------------ |
-| 水                    | 7732-18-3 | H2O        | O                                    |
-| 乙醇                  | 64-17-5   | C2H6O      | CCO                                  |
-| 乙酸                  | 64-19-7   | C2H4O2     | CC(O)=O                              |
-| 甲醇                  | 67-56-1   | CH4O       | CO                                   |
-| 丙酮                  | 67-64-1   | C3H6O      | CC(C)=O                              |
-| 二甲基亚砜(DMSO)      | 67-68-5   | C2H6OS     | CS(C)=O                              |
-| 乙酸乙酯              | 141-78-6  | C4H8O2     | CCOC(C)=O                            |
-| 二氯甲烷              | 75-09-2   | CH2Cl2     | ClCCl                                |
-| 四氢呋喃(THF)         | 109-99-9  | C4H8O      | C1CCOC1                              |
-| N,N-二甲基甲酰胺(DMF) | 68-12-2   | C3H7NO     | CN(C)C=O                             |
-| 氯仿                  | 67-66-3   | CHCl3      | ClC(Cl)Cl                            |
-| 乙腈                  | 75-05-8   | C2H3N      | CC#N                                 |
-| 甲苯                  | 108-88-3  | C7H8       | Cc1ccccc1                            |
-| 正己烷                | 110-54-3  | C6H14      | CCCCCC                               |
-| 异丙醇                | 67-63-0   | C3H8O      | CC(C)O                               |
-| 盐酸                  | 7647-01-0 | HCl        | Cl                                   |
-| 硫酸                  | 7664-93-9 | H2SO4      | OS(O)(=O)=O                          |
-| 氢氧化钠              | 1310-73-2 | NaOH       | [Na]O                                |
-| 碳酸钠                | 497-19-8  | Na2CO3     | [Na]OC([O-])=O.[Na+]                 |
-| 氯化钠                | 7647-14-5 | NaCl       | [Na]Cl                               |
-| 乙二胺四乙酸(EDTA)    | 60-00-4   | C10H16N2O8 | OC(=O)CN(CCN(CC(O)=O)CC(O)=O)CC(O)=O |
-
-> 此表仅供快速参考。对于不在表中的试剂，agent 应根据化学知识推断或提示用户补充。
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 1: 确认 ak/sk → 生成 AUTH token
-- [ ] Step 2: 确认 --addr → 设置 BASE URL
-- [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
-- [ ] Step 4: 收集试剂信息（用户提供列表/逐个描述/CSV文件）
-- [ ] Step 5: 补全缺失字段（CAS、分子式、SMILES 等）
-- [ ] Step 6: 向用户确认待录入的试剂列表
-- [ ] Step 7: 循环调用 POST /lab/reagent 逐条录入（每条需含 lab_uuid）
-- [ ] Step 8: 汇总结果（成功/失败数量及详情）
-```
-
----
-
-## 完整示例
-
-用户说：「帮我录入 3 种试剂：500mL 无水乙醇、1kg 氯化钠、2L 去离子水」
-
-Agent 构建的请求序列：
-
-```json
-// 第 1 条
-{"lab_uuid": "8511c672-...", "cas": "64-17-5", "name": "无水乙醇", "molecular_formula": "C2H6O", "smiles": "CCO", "stock_in_quantity": 500, "unit": "mL", "supplier": "国药集团", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
-
-// 第 2 条
-{"lab_uuid": "8511c672-...", "cas": "7647-14-5", "name": "氯化钠", "molecular_formula": "NaCl", "smiles": "[Na]Cl", "stock_in_quantity": 1, "unit": "kg", "supplier": "", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
-
-// 第 3 条
-{"lab_uuid": "8511c672-...", "cas": "7732-18-3", "name": "去离子水", "molecular_formula": "H2O", "smiles": "O", "stock_in_quantity": 2, "unit": "L", "supplier": "", "production_date": "2025-01-01T00:00:00Z", "expiry_date": "2026-01-01T00:00:00Z"}
-```

.cursor/skills/batch-submit-experiment/SKILL.md

@@ -1,360 +0,0 @@
----
-name: batch-submit-experiment
-description: Batch submit experiments (notebooks) to the Uni-Lab cloud platform (leap-lab) — list workflows, generate node_params from registry schemas, submit multiple rounds, check notebook status. Use when the user wants to submit experiments, create notebooks, batch run workflows, check experiment status, or mentions 提交实验/批量实验/notebook/实验轮次/实验状态.
----
-
-# Uni-Lab 批量提交实验指南
-
-通过 Uni-Lab 云端 API 批量提交实验（notebook），支持多轮实验参数配置。根据 workflow 模板详情和本地设备注册表自动生成 `node_params` 模板。
-
-> **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
-
-## 前置条件（缺一不可）
-
-使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
-
-生成 AUTH token（任选一种方式）：
-
-```bash
-# 方式一：Python 一行生成（注意：scheme 是 "Lab" 不是 "Basic"）
-python -c "import base64,sys; print('Authorization: Lab ' + base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
-
-# 方式二：手动计算
-# base64(ak:sk) → Authorization: Lab <token>
-# ⚠️ 这里的 "Lab" 是 Uni-Lab 平台的 auth scheme，绝对不能用 "Basic" 替代
-```
-
-### 2. --addr → BASE URL
-
-| `--addr` 值  | BASE                                |
-| ------------ | ----------------------------------- |
-| `test`       | `https://leap-lab.test.bohrium.com` |
-| `uat`        | `https://leap-lab.uat.bohrium.com`  |
-| `local`      | `http://127.0.0.1:48197`            |
-| 不传（默认） | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-# ⚠️ Auth scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
-AUTH="Authorization: Lab <上面命令输出的 token>"
-```
-
-### 3. req_device_registry_upload.json（设备注册表）
-
-**批量提交实验时需要本地注册表来解析 workflow 节点的参数 schema。**
-
-**必须先用 Glob 工具搜索文件**，不要直接猜测路径：
-
-```
-Glob: **/req_device_registry_upload.json
-```
-
-常见位置（仅供参考，以 Glob 实际结果为准）：
-- `<workspace>/unilabos_data/req_device_registry_upload.json`
-- `<workspace>/req_device_registry_upload.json`
-
-找到后**检查文件修改时间**并告知用户。超过 1 天提醒用户是否需要重新启动 `unilab`。
-
-**如果 Glob 搜索无结果** → 告知用户先运行 `unilab` 启动命令，等注册表生成后再执行。可跳过此步，但将无法自动生成参数模板，需要用户手动填写 `param`。
-
-### 4. workflow_uuid（目标工作流）
-
-用户需要提供要提交的 workflow UUID。如果用户不确定，通过 API #3 列出可用 workflow 供选择。
-
-**四项全部就绪后才可开始。**
-
-## Session State
-
-在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：
-
-- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
-- `project_uuid` — 项目 UUID（通过 API #2 列出项目列表，**让用户选择**）
-- `workflow_uuid` — 工作流 UUID（用户提供或从列表选择）
-- `workflow_nodes` — workflow 中各 action 节点的 uuid、设备 ID、动作名（从 API #4 获取）
-
-## 请求约定
-
-所有请求使用 `curl -s`，POST 需加 `Content-Type: application/json`。
-
-> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
->
-> **PowerShell JSON 传参**：PowerShell 中 `-d '{"key":"value"}'` 会因引号转义失败。请将 JSON 写入临时文件，用 `-d '@tmp_body.json'`（单引号包裹 `@`，否则会被解析为 splatting 运算符）。
-
----
-
-## API Endpoints
-
-### 1. 获取实验室信息（自动获取 lab_uuid）
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回：
-
-```json
-{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
-```
-
-记住 `data.uuid` 为 `lab_uuid`。
-
-### 2. 列出实验室项目（让用户选择项目）
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/project/list?lab_uuid=$lab_uuid" -H "$AUTH"
-```
-
-返回：
-
-```json
-{
-  "code": 0,
-  "data": {
-    "items": [
-      {
-        "uuid": "1b3f249a-...",
-        "name": "bt",
-        "description": null,
-        "status": "active",
-        "created_at": "2026-04-09T14:31:28+08:00"
-      },
-      {
-        "uuid": "b6366243-...",
-        "name": "default",
-        "description": "默认项目",
-        "status": "active",
-        "created_at": "2026-03-26T11:13:36+08:00"
-      }
-    ]
-  }
-}
-```
-
-展示 `data.items[]` 中每个项目的 `name` 和 `uuid`，让用户选择。用户**必须**选择一个项目，记住 `project_uuid`（即选中项目的 `uuid`），后续创建 notebook 时需要提供。
-
-### 3. 列出可用 workflow
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/workflow/workflows?page=1&page_size=20&lab_uuid=$lab_uuid" -H "$AUTH"
-```
-
-返回 workflow 列表，展示给用户选择。列出每个 workflow 的 `uuid` 和 `name`。
-
-### 4. 获取 workflow 模板详情
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
-```
-
-返回 workflow 的完整结构，包含所有 action 节点信息。需要从响应中提取：
-
-- 每个 action 节点的 `node_uuid`
-- 每个节点对应的设备 ID（`resource_template_name`）
-- 每个节点的动作名（`node_template_name`）
-- 每个节点的现有参数（`param`）
-
-> **注意**：此 API 返回格式可能因版本不同而有差异。首次调用时，先打印完整响应分析结构，再提取节点信息。常见的节点字段路径为 `data.nodes[]` 或 `data.workflow_nodes[]`。
-
-### 5. 提交实验（创建 notebook）
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/notebook" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '<request_body>'
-```
-
-请求体结构：
-
-```json
-{
-  "lab_uuid": "<lab_uuid>",
-  "project_uuid": "<project_uuid>",
-  "workflow_uuid": "<workflow_uuid>",
-  "name": "<实验名称>",
-  "node_params": [
-    {
-      "sample_uuids": ["<样品UUID1>", "<样品UUID2>"],
-      "datas": [
-        {
-          "node_uuid": "<workflow中的节点UUID>",
-          "param": {},
-          "sample_params": [
-            {
-              "container_uuid": "<容器UUID>",
-              "sample_value": {
-                "liquid_names": "<液体名称>",
-                "volumes": 1000
-              }
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}
-```
-
-> **注意**：`sample_uuids` 必须是 **UUID 数组**（`[]uuid.UUID`），不是字符串。无样品时传空数组 `[]`。
-
-### 6. 查询 notebook 状态
-
-提交成功后，使用返回的 notebook UUID 查询执行状态：
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/notebook/status?uuid=$notebook_uuid" -H "$AUTH"
-```
-
-提交后应**立即查询一次**状态，确认 notebook 已被正确接收并开始调度。
-
----
-
-## Notebook 请求体详解
-
-### node_params 结构
-
-`node_params` 是一个数组，**每个元素代表一轮实验**：
-
-- 要跑 2 轮 → `node_params` 有 2 个元素
-- 要跑 N 轮 → `node_params` 有 N 个元素
-
-### 每轮的字段
-
-| 字段           | 类型          | 说明                                      |
-| -------------- | ------------- | ----------------------------------------- |
-| `sample_uuids` | array\<uuid\> | 该轮实验的样品 UUID 数组，无样品时传 `[]` |
-| `datas`        | array         | 该轮中每个 workflow 节点的参数配置        |
-
-### datas 中每个节点
-
-| 字段            | 类型   | 说明                                         |
-| --------------- | ------ | -------------------------------------------- |
-| `node_uuid`     | string | workflow 模板中的节点 UUID（从 API #4 获取） |
-| `param`         | object | 动作参数（根据本地注册表 schema 填写）       |
-| `sample_params` | array  | 样品相关参数（液体名、体积等）               |
-
-### sample_params 中每条
-
-| 字段             | 类型   | 说明                                                 |
-| ---------------- | ------ | ---------------------------------------------------- |
-| `container_uuid` | string | 容器 UUID                                            |
-| `sample_value`   | object | 样品值，如 `{"liquid_names": "水", "volumes": 1000}` |
-
----
-
-## 从本地注册表生成 param 模板
-
-### 自动方式 — 运行脚本
-
-```bash
-python scripts/gen_notebook_params.py \
-  --auth <token> \
-  --base <BASE_URL> \
-  --workflow-uuid <workflow_uuid> \
-  [--registry <path/to/req_device_registry_upload.json>] \
-  [--rounds <轮次数>] \
-  [--output <输出文件路径>]
-```
-
-> 脚本位于本文档同级目录下的 `scripts/gen_notebook_params.py`。
-
-脚本会：
-
-1. 调用 workflow detail API 获取所有 action 节点
-2. 读取本地注册表，为每个节点查找对应的 action schema
-3. 生成 `notebook_template.json`，包含：
-   - 完整 `node_params` 骨架
-   - 每个节点的 param 字段及类型说明
-   - `_schema_info` 辅助信息（不提交，仅供参考）
-
-### 手动方式
-
-如果脚本不可用或注册表不存在：
-
-1. 调用 API #4 获取 workflow 详情
-2. 找到每个 action 节点的 `node_uuid`
-3. 在本地注册表中查找对应设备的 `action_value_mappings`：
-   ```
-   resources[].id == <device_id>
-   → resources[].class.action_value_mappings.<action_name>.schema.properties.goal.properties
-   ```
-4. 将 schema 中的 properties 作为 `param` 的字段模板
-5. 按轮次复制 `node_params` 元素，让用户填写每轮的具体值
-
-### 注册表结构参考
-
-```json
-{
-  "resources": [
-    {
-      "id": "liquid_handler.prcxi",
-      "class": {
-        "module": "unilabos.devices.xxx:ClassName",
-        "action_value_mappings": {
-          "transfer_liquid": {
-            "type": "LiquidHandlerTransfer",
-            "schema": {
-              "properties": {
-                "goal": {
-                  "properties": {
-                    "asp_vols": {
-                      "type": "array",
-                      "items": { "type": "number" }
-                    },
-                    "sources": { "type": "array" }
-                  },
-                  "required": ["asp_vols", "sources"]
-                }
-              }
-            },
-            "goal_default": {}
-          }
-        }
-      }
-    }
-  ]
-}
-```
-
-`param` 填写时，使用 `goal.properties` 中的字段名和类型。
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 1: 确认 ak/sk → 生成 AUTH token
-- [ ] Step 2: 确认 --addr → 设置 BASE URL
-- [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
-- [ ] Step 4: GET /lab/project/list → 列出项目，让用户选择 → 获取 project_uuid
-- [ ] Step 5: 确认 workflow_uuid（用户提供或从 GET #3 列表选择）
-- [ ] Step 6: GET workflow detail (#4) → 提取各节点 uuid、设备ID、动作名
-- [ ] Step 7: 定位本地注册表 req_device_registry_upload.json
-- [ ] Step 8: 运行 gen_notebook_params.py 或手动匹配 → 生成 node_params 模板
-- [ ] Step 9: 引导用户填写每轮的参数（sample_uuids、param、sample_params）
-- [ ] Step 10: 构建完整请求体（含 project_uuid）→ POST /lab/notebook 提交
-- [ ] Step 11: 检查返回结果，记录 notebook UUID
-- [ ] Step 12: GET /lab/notebook/status → 查询 notebook 状态，确认已调度
-```
-
----
-
-## 常见问题
-
-### Q: workflow 中有多个节点，每轮都要填所有节点的参数吗？
-
-是的。`datas` 数组中需要包含该轮实验涉及的每个 workflow 节点的参数。通常每个 action 节点都需要一条 `datas` 记录。
-
-### Q: 多轮实验的参数完全不同吗？
-
-通常每轮的 `param`（设备动作参数）可能相同或相似，但 `sample_uuids` 和 `sample_params`（样品信息）每轮不同。脚本生成模板时会按轮次复制骨架，用户只需修改差异部分。
-
-### Q: 如何获取 sample_uuids 和 container_uuid？
-
-这些 UUID 通常来自实验室的样品管理系统。向用户询问，或从资源树（API `GET /lab/material/download/$lab_uuid`）中查找。

.cursor/skills/batch-submit-experiment/scripts/gen_notebook_params.py

@@ -1,395 +0,0 @@
-#!/usr/bin/env python3
-"""
-从 workflow 模板详情 + 本地设备注册表生成 notebook 提交用的 node_params 模板。
-
-用法:
-  python gen_notebook_params.py --auth <token> --base <url> --workflow-uuid <uuid> [选项]
-
-选项:
-  --auth <token>          Lab token（base64(ak:sk) 的结果，不含 "Lab " 前缀）
-  --base <url>            API 基础 URL（如 https://leap-lab.test.bohrium.com）
-  --workflow-uuid <uuid>  目标 workflow 的 UUID
-  --registry <path>       本地注册表文件路径（默认自动搜索）
-  --rounds <n>            实验轮次数（默认 1）
-  --output <path>         输出模板文件路径（默认 notebook_template.json）
-  --dump-response         打印 workflow detail API 的原始响应（调试用）
-
-示例:
-  python gen_notebook_params.py \\
-    --auth YTFmZDlkNGUtxxxx \\
-    --base https://leap-lab.test.bohrium.com \\
-    --workflow-uuid abc-123-def \\
-    --rounds 2
-"""
-import copy
-import json
-import os
-import sys
-from datetime import datetime
-from urllib.request import Request, urlopen
-from urllib.error import HTTPError, URLError
-
-REGISTRY_FILENAME = "req_device_registry_upload.json"
-
-
-def find_registry(explicit_path=None):
-    """查找本地注册表文件，逻辑同 extract_device_actions.py"""
-    if explicit_path:
-        if os.path.isfile(explicit_path):
-            return explicit_path
-        if os.path.isdir(explicit_path):
-            fp = os.path.join(explicit_path, REGISTRY_FILENAME)
-            if os.path.isfile(fp):
-                return fp
-        print(f"警告: 指定的注册表路径不存在: {explicit_path}")
-        return None
-
-    candidates = [
-        os.path.join("unilabos_data", REGISTRY_FILENAME),
-        REGISTRY_FILENAME,
-    ]
-    for c in candidates:
-        if os.path.isfile(c):
-            return c
-
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    workspace_root = os.path.normpath(os.path.join(script_dir, "..", "..", ".."))
-    for c in candidates:
-        path = os.path.join(workspace_root, c)
-        if os.path.isfile(path):
-            return path
-
-    cwd = os.getcwd()
-    for _ in range(5):
-        parent = os.path.dirname(cwd)
-        if parent == cwd:
-            break
-        cwd = parent
-        for c in candidates:
-            path = os.path.join(cwd, c)
-            if os.path.isfile(path):
-                return path
-    return None
-
-
-def load_registry(path):
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def build_registry_index(registry_data):
-    """构建 device_id → action_value_mappings 的索引"""
-    index = {}
-    for res in registry_data.get("resources", []):
-        rid = res.get("id", "")
-        avm = res.get("class", {}).get("action_value_mappings", {})
-        if rid and avm:
-            index[rid] = avm
-    return index
-
-
-def flatten_goal_schema(action_data):
-    """从 action_value_mappings 条目中提取 goal 层的 schema"""
-    schema = action_data.get("schema", {})
-    goal_schema = schema.get("properties", {}).get("goal", {})
-    return goal_schema if goal_schema else schema
-
-
-def build_param_template(goal_schema):
-    """根据 goal schema 生成 param 模板，含类型标注"""
-    properties = goal_schema.get("properties", {})
-    required = set(goal_schema.get("required", []))
-    template = {}
-    for field_name, field_def in properties.items():
-        if field_name == "unilabos_device_id":
-            continue
-        ftype = field_def.get("type", "any")
-        default = field_def.get("default")
-        if default is not None:
-            template[field_name] = default
-        elif ftype == "string":
-            template[field_name] = f"$TODO ({ftype}, {'required' if field_name in required else 'optional'})"
-        elif ftype == "number" or ftype == "integer":
-            template[field_name] = 0
-        elif ftype == "boolean":
-            template[field_name] = False
-        elif ftype == "array":
-            template[field_name] = []
-        elif ftype == "object":
-            template[field_name] = {}
-        else:
-            template[field_name] = f"$TODO ({ftype})"
-    return template
-
-
-def fetch_workflow_detail(base_url, auth_token, workflow_uuid):
-    """调用 workflow detail API"""
-    url = f"{base_url}/api/v1/lab/workflow/template/detail/{workflow_uuid}"
-    req = Request(url, method="GET")
-    req.add_header("Authorization", f"Lab {auth_token}")
-    try:
-        with urlopen(req, timeout=30) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except HTTPError as e:
-        body = e.read().decode("utf-8", errors="replace")
-        print(f"API 错误 {e.code}: {body}")
-        return None
-    except URLError as e:
-        print(f"网络错误: {e.reason}")
-        return None
-
-
-def extract_nodes_from_response(response):
-    """
-    从 workflow detail 响应中提取 action 节点列表。
-    适配多种可能的响应格式。
-
-    返回: [(node_uuid, resource_template_name, node_template_name, existing_param), ...]
-    """
-    data = response.get("data", response)
-
-    search_keys = ["nodes", "workflow_nodes", "node_list", "steps"]
-    nodes_raw = None
-    for key in search_keys:
-        if key in data and isinstance(data[key], list):
-            nodes_raw = data[key]
-            break
-
-    if nodes_raw is None:
-        if isinstance(data, list):
-            nodes_raw = data
-        else:
-            for v in data.values():
-                if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
-                    nodes_raw = v
-                    break
-
-    if not nodes_raw:
-        print("警告: 未能从响应中提取节点列表")
-        print("响应顶层 keys:", list(data.keys()) if isinstance(data, dict) else type(data).__name__)
-        return []
-
-    result = []
-    for node in nodes_raw:
-        if not isinstance(node, dict):
-            continue
-
-        node_uuid = (
-            node.get("uuid")
-            or node.get("node_uuid")
-            or node.get("id")
-            or ""
-        )
-        resource_name = (
-            node.get("resource_template_name")
-            or node.get("device_id")
-            or node.get("resource_name")
-            or node.get("device_name")
-            or ""
-        )
-        template_name = (
-            node.get("node_template_name")
-            or node.get("action_name")
-            or node.get("template_name")
-            or node.get("action")
-            or node.get("name")
-            or ""
-        )
-        existing_param = node.get("param", {}) or {}
-
-        if node_uuid:
-            result.append((node_uuid, resource_name, template_name, existing_param))
-
-    return result
-
-
-def generate_template(nodes, registry_index, rounds):
-    """生成 notebook 提交模板"""
-    node_params = []
-    schema_info = {}
-
-    datas_template = []
-    for node_uuid, resource_name, template_name, existing_param in nodes:
-        param_template = {}
-        matched = False
-
-        if resource_name and template_name and resource_name in registry_index:
-            avm = registry_index[resource_name]
-            if template_name in avm:
-                goal_schema = flatten_goal_schema(avm[template_name])
-                param_template = build_param_template(goal_schema)
-                goal_default = avm[template_name].get("goal_default", {})
-                if goal_default:
-                    for k, v in goal_default.items():
-                        if k in param_template and v is not None:
-                            param_template[k] = v
-                matched = True
-
-                schema_info[node_uuid] = {
-                    "device_id": resource_name,
-                    "action_name": template_name,
-                    "action_type": avm[template_name].get("type", ""),
-                    "schema_properties": list(goal_schema.get("properties", {}).keys()),
-                    "required": goal_schema.get("required", []),
-                }
-
-        if not matched and existing_param:
-            param_template = existing_param
-
-        if not matched and not existing_param:
-            schema_info[node_uuid] = {
-                "device_id": resource_name,
-                "action_name": template_name,
-                "warning": "未在本地注册表中找到匹配的 action schema",
-            }
-
-        datas_template.append({
-            "node_uuid": node_uuid,
-            "param": param_template,
-            "sample_params": [
-                {
-                    "container_uuid": "$TODO_CONTAINER_UUID",
-                    "sample_value": {
-                        "liquid_names": "$TODO_LIQUID_NAME",
-                        "volumes": 0,
-                    },
-                }
-            ],
-        })
-
-    for i in range(rounds):
-        node_params.append({
-            "sample_uuids": f"$TODO_SAMPLE_UUID_ROUND_{i + 1}",
-            "datas": copy.deepcopy(datas_template),
-        })
-
-    return {
-        "lab_uuid": "$TODO_LAB_UUID",
-        "project_uuid": "$TODO_PROJECT_UUID",
-        "workflow_uuid": "$TODO_WORKFLOW_UUID",
-        "name": "$TODO_EXPERIMENT_NAME",
-        "node_params": node_params,
-        "_schema_info（仅参考，提交时删除）": schema_info,
-    }
-
-
-def parse_args(argv):
-    """简单的参数解析"""
-    opts = {
-        "auth": None,
-        "base": None,
-        "workflow_uuid": None,
-        "registry": None,
-        "rounds": 1,
-        "output": "notebook_template.json",
-        "dump_response": False,
-    }
-    i = 0
-    while i < len(argv):
-        arg = argv[i]
-        if arg == "--auth" and i + 1 < len(argv):
-            opts["auth"] = argv[i + 1]
-            i += 2
-        elif arg == "--base" and i + 1 < len(argv):
-            opts["base"] = argv[i + 1].rstrip("/")
-            i += 2
-        elif arg == "--workflow-uuid" and i + 1 < len(argv):
-            opts["workflow_uuid"] = argv[i + 1]
-            i += 2
-        elif arg == "--registry" and i + 1 < len(argv):
-            opts["registry"] = argv[i + 1]
-            i += 2
-        elif arg == "--rounds" and i + 1 < len(argv):
-            opts["rounds"] = int(argv[i + 1])
-            i += 2
-        elif arg == "--output" and i + 1 < len(argv):
-            opts["output"] = argv[i + 1]
-            i += 2
-        elif arg == "--dump-response":
-            opts["dump_response"] = True
-            i += 1
-        else:
-            print(f"未知参数: {arg}")
-            i += 1
-    return opts
-
-
-def main():
-    opts = parse_args(sys.argv[1:])
-
-    if not opts["auth"] or not opts["base"] or not opts["workflow_uuid"]:
-        print("用法:")
-        print("  python gen_notebook_params.py --auth <token> --base <url> --workflow-uuid <uuid> [选项]")
-        print()
-        print("必需参数:")
-        print("  --auth <token>          Lab token（base64(ak:sk)）")
-        print("  --base <url>            API 基础 URL")
-        print("  --workflow-uuid <uuid>  目标 workflow UUID")
-        print()
-        print("可选参数:")
-        print("  --registry <path>       注册表文件路径（默认自动搜索）")
-        print("  --rounds <n>            实验轮次数（默认 1）")
-        print("  --output <path>         输出文件路径（默认 notebook_template.json）")
-        print("  --dump-response         打印 API 原始响应")
-        sys.exit(1)
-
-    # 1. 查找并加载本地注册表
-    registry_path = find_registry(opts["registry"])
-    registry_index = {}
-    if registry_path:
-        mtime = os.path.getmtime(registry_path)
-        gen_time = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
-        print(f"注册表: {registry_path}  (生成时间: {gen_time})")
-        registry_data = load_registry(registry_path)
-        registry_index = build_registry_index(registry_data)
-        print(f"已索引 {len(registry_index)} 个设备的 action schemas")
-    else:
-        print("警告: 未找到本地注册表，将跳过 param 模板生成")
-        print("  提交时需要手动填写各节点的 param 字段")
-
-    # 2. 获取 workflow 详情
-    print(f"\n正在获取 workflow 详情: {opts['workflow_uuid']}")
-    response = fetch_workflow_detail(opts["base"], opts["auth"], opts["workflow_uuid"])
-    if not response:
-        print("错误: 无法获取 workflow 详情")
-        sys.exit(1)
-
-    if opts["dump_response"]:
-        print("\n=== API 原始响应 ===")
-        print(json.dumps(response, indent=2, ensure_ascii=False)[:5000])
-        print("=== 响应结束（截断至 5000 字符） ===\n")
-
-    # 3. 提取节点
-    nodes = extract_nodes_from_response(response)
-    if not nodes:
-        print("错误: 未能从 workflow 中提取任何 action 节点")
-        print("请使用 --dump-response 查看原始响应结构")
-        sys.exit(1)
-
-    print(f"\n找到 {len(nodes)} 个 action 节点:")
-    print(f"  {'节点 UUID':<40} {'设备 ID':<30} {'动作名':<25} {'Schema'}")
-    print("  " + "-" * 110)
-    for node_uuid, resource_name, template_name, _ in nodes:
-        matched = "✓" if (resource_name in registry_index and
-                          template_name in registry_index.get(resource_name, {})) else "✗"
-        print(f"  {node_uuid:<40} {resource_name:<30} {template_name:<25} {matched}")
-
-    # 4. 生成模板
-    template = generate_template(nodes, registry_index, opts["rounds"])
-    template["workflow_uuid"] = opts["workflow_uuid"]
-
-    output_path = opts["output"]
-    with open(output_path, "w", encoding="utf-8") as f:
-        json.dump(template, f, indent=2, ensure_ascii=False)
-    print(f"\n模板已写入: {output_path}")
-    print(f"  轮次数: {opts['rounds']}")
-    print(f"  节点数/轮: {len(nodes)}")
-    print()
-    print("下一步:")
-    print("  1. 打开模板文件，将 $TODO 占位符替换为实际值")
-    print("  2. 删除 _schema_info 字段（仅供参考）")
-    print("  3. 使用 POST /api/v1/lab/notebook 提交")
-
-
-if __name__ == "__main__":
-    main()

.cursor/skills/create-device-skill/SKILL.md

@@ -1,500 +0,0 @@
----
-name: create-device-skill
-description: Create a skill for any Uni-Lab device by extracting action schemas from the device registry. Use when the user wants to create a new device skill, add device API documentation, or set up action schemas for a device.
----
-
-# 创建设备 Skill 指南
-
-本 meta-skill 教你如何为任意 Uni-Lab-OS 设备创建完整的 API 操作技能（参考 `unilab-device-api` 的成功案例）。
-
-## 数据源
-
-- **设备注册表**: `unilabos_data/req_device_registry_upload.json`
-- **结构**: `{ "resources": [{ "id": "<device_id>", "class": { "module": "<python_module:ClassName>", "action_value_mappings": { ... } } }] }`
-- **生成时机**: `unilab` 启动并完成注册表上传后自动生成
-- **module 字段**: 格式 `unilabos.devices.xxx.yyy:ClassName`，可转为源码路径 `unilabos/devices/xxx/yyy.py`，阅读源码可了解参数含义和设备行为
-
-## 创建流程
-
-### Step 0 — 收集必备信息（缺一不可，否则询问后终止）
-
-开始前**必须**确认以下 4 项信息全部就绪。如果用户未提供任何一项，**立即询问并终止当前流程**，等用户补齐后再继续。
-
-向用户提问：「请提供你的 unilab 启动参数，我需要以下信息：」
-
-#### 必备项 ①：ak / sk（认证凭据）
-
-来源：启动命令的 `--ak` `--sk` 参数，或 config.py 中的 `ak = "..."` `sk = "..."`。
-
-获取后立即生成 AUTH token：
-
-```bash
-python ./scripts/gen_auth.py <ak> <sk>
-# 或从 config.py 提取
-python ./scripts/gen_auth.py --config <config.py>
-```
-
-认证算法：`base64(ak:sk)` → `Authorization: Lab <token>`
-
-#### 必备项 ②：--addr（目标环境）
-
-决定 API 请求发往哪个服务器。从启动命令的 `--addr` 参数获取：
-
-| `--addr` 值    | BASE URL                            |
-| -------------- | ----------------------------------- |
-| `test`         | `https://leap-lab.test.bohrium.com` |
-| `uat`          | `https://leap-lab.uat.bohrium.com`  |
-| `local`        | `http://127.0.0.1:48197`            |
-| 不传（默认）   | `https://leap-lab.bohrium.com`      |
-| 其他自定义 URL | 直接使用该 URL                      |
-
-#### 必备项 ③：req_device_registry_upload.json（设备注册表）
-
-数据文件由 `unilab` 启动时自动生成，需要定位它：
-
-**推断 working_dir**（即 `unilabos_data` 所在目录）：
-
-| 条件                 | working_dir 取值                                         |
-| -------------------- | -------------------------------------------------------- |
-| 传了 `--working_dir` | `<working_dir>/unilabos_data/`（若子目录已存在则直接用） |
-| 仅传了 `--config`    | `<config 文件所在目录>/unilabos_data/`                   |
-| 都没传               | `<当前工作目录>/unilabos_data/`                          |
-
-**按优先级搜索文件**：
-
-```
-<推断的 working_dir>/unilabos_data/req_device_registry_upload.json
-<推断的 working_dir>/req_device_registry_upload.json
-<workspace 根目录>/unilabos_data/req_device_registry_upload.json
-```
-
-也可以直接 Glob 搜索：`**/req_device_registry_upload.json`
-
-找到后**必须检查文件修改时间**并告知用户：「找到注册表文件 `<路径>`，生成于 `<时间>`。请确认这是最近一次启动生成的。」超过 1 天提醒用户是否需要重新启动 `unilab`。
-
-**如果文件不存在** → 告知用户先运行 `unilab` 启动命令，等日志出现 `注册表响应数据已保存` 后再执行本流程。**终止。**
-
-#### 必备项 ④：目标设备
-
-用户需要明确要为哪个设备创建 skill。可以是设备名称（如「PRCXI 移液站」）或 device_id（如 `liquid_handler.prcxi`）。
-
-如果用户不确定，运行提取脚本列出所有设备供选择：
-
-```bash
-python ./scripts/extract_device_actions.py --registry <找到的文件路径>
-```
-
-**四项全部就绪后才进入 Step 1。**
-
-### Step 1 — 列出可用设备
-
-运行提取脚本，列出所有设备及 action 数量和 Python 源码路径，让用户选择：
-
-```bash
-# 自动搜索（默认在 unilabos_data/ 和当前目录查找）
-python ./scripts/extract_device_actions.py
-
-# 指定注册表文件路径
-python ./scripts/extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
-```
-
-脚本输出包含每个设备的 **Python 源码路径**（从 `class.module` 转换），可用于后续阅读源码理解参数含义。
-
-### Step 2 — 提取 Action Schema
-
-用户选择设备后，运行提取脚本：
-
-```bash
-python ./scripts/extract_device_actions.py [--registry <path>] <device_id> ./skills/<skill-name>/actions/
-```
-
-脚本会显示设备的 Python 源码路径和类名，方便阅读源码了解参数含义。
-
-每个 action 生成一个 JSON 文件，包含：
-
-- `type` — 作为 API 调用的 `action_type`
-- `schema` — 完整 JSON Schema（含 `properties.goal.properties` 参数定义）
-- `goal` — goal 字段映射（含占位符 `$placeholder`）
-- `goal_default` — 默认值
-
-### Step 3 — 写 action-index.md
-
-按模板为每个 action 写条目（**必须包含 `action_type`**）：
-
-```markdown
-### `<action_name>`
-
-<用途描述（一句话）>
-
-- **action_type**: `<从 actions/<name>.json 的 type 字段获取>`
-- **Schema**: [`actions/<filename>.json`](actions/<filename>.json)
-- **核心参数**: `param1`, `param2`（从 schema.required 获取）
-- **可选参数**: `param3`, `param4`
-- **占位符字段**: `field`（需填入物料信息，值以 `$` 开头）
-```
-
-描述规则：
-
-- **每个 action 必须标注 `action_type`**（从 JSON 的 `type` 字段读取），这是 API #9 调用时的必填参数，传错会导致任务永远卡住
-- 从 `schema.properties` 读参数列表（schema 已提升为 goal 内容）
-- 从 `schema.required` 区分核心/可选参数
-- 按功能分类（移液、枪头、外设等）
-- 标注 `placeholder_keys` 中的字段类型：
-  - `unilabos_resources` → **ResourceSlot**，填入 `{id, name, uuid}`（id 是路径格式，从资源树取物料节点）
-  - `unilabos_devices` → **DeviceSlot**，填入路径字符串如 `"/host_node"`（从资源树筛选 type=device）
-  - `unilabos_nodes` → **NodeSlot**，填入路径字符串如 `"/PRCXI/PRCXI_Deck"`（资源树中任意节点）
-  - `unilabos_class` → **ClassSlot**，填入类名字符串如 `"container"`（从注册表查找）
-  - `unilabos_formulation` → **FormulationSlot**，填入配方数组 `[{well_name, liquids: [{name, volume}]}]`（well_name 为目标物料的 name）
-- array 类型字段 → `[{id, name, uuid}, ...]`
-- 特殊：`create_resource` 的 `res_id`（ResourceSlot）可填不存在的路径
-
-### Step 4 — 写 SKILL.md
-
-直接复用 `unilab-device-api` 的 API 模板，修改：
-
-- 设备名称
-- Action 数量
-- 目录列表
-- Session state 中的 `device_name`
-- **AUTH 头** — 使用 Step 0 中 `gen_auth.py` 生成的 `Authorization: Lab <token>`（不要硬编码 `Api` 类型的 key）
-- **Python 源码路径** — 在 SKILL.md 开头注明设备对应的源码文件，方便参考参数含义
-- **Slot 字段表** — 列出本设备哪些 action 的哪些字段需要填入 Slot（物料/设备/节点/类名）
-- **action_type 速查表** — 在 API #9 说明后面紧跟一个表格，列出每个 action 对应的 `action_type` 值（从 JSON `type` 字段提取），方便 agent 快速查找而无需打开 JSON 文件
-
-API 模板结构：
-
-```markdown
-## 设备信息
-
-- device_id, Python 源码路径, 设备类名
-
-## 前置条件（缺一不可）
-
-- ak/sk → AUTH, --addr → BASE URL
-
-## 请求约定
-
-- Windows 平台必须用 curl.exe（非 PowerShell 的 curl 别名）
-
-## Session State
-
-- lab_uuid（通过 GET /edge/lab/info 直接获取，不要问用户）, device_name
-
-## API Endpoints
-
-# - #1 GET /edge/lab/info → 直接拿到 lab_uuid
-
-# - #2 创建工作流 POST /lab/workflow/owner → 拼 URL 告知用户
-
-# - #3 创建节点 POST /edge/workflow/node
-
-# body: {workflow_uuid, resource_template_name: "<device_id>", node_template_name: "<action_name>"}
-
-# - #4 删除节点 DELETE /lab/workflow/nodes
-
-# - #5 更新节点参数 PATCH /lab/workflow/node
-
-# - #6 查询节点 handles POST /lab/workflow/node-handles
-
-# body: {node_uuids: ["uuid1","uuid2"]} → 返回各节点的 handle_uuid
-
-# - #7 批量创建边 POST /lab/workflow/edges
-
-# body: {edges: [{source_node_uuid, target_node_uuid, source_handle_uuid, target_handle_uuid}]}
-
-# - #8 启动工作流 POST /lab/workflow/{uuid}/run
-
-# - #9 运行设备单动作 POST /lab/mcp/run/action（⚠️ action_type 必须从 action-index.md 或 actions/<name>.json 的 type 字段获取，传错会导致任务永远卡住）
-
-# - #10 查询任务状态 GET /lab/mcp/task/{task_uuid}
-
-# - #11 运行工作流单节点 POST /lab/mcp/run/workflow/action
-
-# - #12 获取资源树 GET /lab/material/download/{lab_uuid}
-
-# - #13 获取工作流模板详情 GET /lab/workflow/template/detail/{workflow_uuid}
-
-# 返回 workflow 完整结构：data.nodes[] 含每个节点的 uuid、name、param、device_name、handles
-
-# - #14 按名称查询物料模板 GET /lab/material/template/by-name?lab_uuid=&name=
-
-# 返回 res_template_uuid，用于 #15 创建物料时的必填字段
-
-# - #15 创建物料节点 POST /edge/material/node
-
-# body: {res_template_uuid(从#14获取), name(自定义), display_name, parent_uuid?(从#12获取), ...}
-
-# - #16 更新物料节点 PUT /edge/material/node
-
-# body: {uuid(从#12获取), display_name?, description?, init_param_data?, data?, ...}
-
-## Placeholder Slot 填写规则
-
-- unilabos_resources → ResourceSlot → {"id":"/path/name","name":"name","uuid":"xxx"}
-- unilabos_devices → DeviceSlot → "/parent/device" 路径字符串
-- unilabos_nodes → NodeSlot → "/parent/node" 路径字符串
-- unilabos_class → ClassSlot → "class_name" 字符串
-- unilabos_formulation → FormulationSlot → [{well_name, liquids: [{name, volume}]}] 配方数组
-- 特例：create_resource 的 res_id 允许填不存在的路径
-- 列出本设备所有 Slot 字段、类型及含义
-
-## 渐进加载策略
-
-## 完整工作流 Checklist
-```
-
-### Step 5 — 验证
-
-检查文件完整性：
-
-- [ ] `SKILL.md` 包含 API endpoint（#1 获取 lab_uuid、#2-#7 工作流/节点/边、#8-#11 运行/查询、#12 资源树、#13 工作流模板详情、#14-#16 物料管理）
-- [ ] `SKILL.md` 包含 Placeholder Slot 填写规则（ResourceSlot / DeviceSlot / NodeSlot / ClassSlot / FormulationSlot + create_resource 特例）和本设备的 Slot 字段表
-- [ ] `action-index.md` 列出所有 action 并有描述
-- [ ] `actions/` 目录中每个 action 有对应 JSON 文件
-- [ ] JSON 文件包含 `type`, `schema`（已提升为 goal 内容）, `goal`, `goal_default`, `placeholder_keys` 字段
-- [ ] 描述能让 agent 判断该用哪个 action
-
-## Action JSON 文件结构
-
-```json
-{
-  "type": "LiquidHandlerTransfer",    // → API 的 action_type
-  "goal": {                           // goal 字段映射
-    "sources": "sources",
-    "targets": "targets",
-    "tip_racks": "tip_racks",
-    "asp_vols": "asp_vols"
-  },
-  "schema": {                         // ← 直接是 goal 的 schema（已提升）
-    "type": "object",
-    "properties": {                   // 参数定义（即请求中 goal 的字段）
-      "sources": { "type": "array", "items": { "type": "object" } },
-      "targets": { "type": "array", "items": { "type": "object" } },
-      "asp_vols": { "type": "array", "items": { "type": "number" } }
-    },
-    "required": [...],
-    "_unilabos_placeholder_info": {   // ← Slot 类型标记
-      "sources": "unilabos_resources",
-      "targets": "unilabos_resources",
-      "tip_racks": "unilabos_resources"
-    }
-  },
-  "goal_default": { ... },            // 默认值
-  "placeholder_keys": {               // ← 汇总所有 Slot 字段
-    "sources": "unilabos_resources",  //    ResourceSlot
-    "targets": "unilabos_resources",
-    "tip_racks": "unilabos_resources",
-    "target_device_id": "unilabos_devices"  // DeviceSlot
-  }
-}
-```
-
-> **注意**：`schema` 已由脚本从原始 `schema.properties.goal` 提升为顶层，直接包含参数定义。
-> `schema.properties` 中的字段即为 API 创建节点返回的 `data.param` 中的字段，PATCH 更新时直接修改 `param` 即可。
-
-## Placeholder Slot 类型体系
-
-`placeholder_keys` / `_unilabos_placeholder_info` 中有 5 种值，对应不同的填写方式：
-
-| placeholder 值         | Slot 类型       | 填写格式                                              | 选取范围                                  |
-| ---------------------- | --------------- | ----------------------------------------------------- | ----------------------------------------- |
-| `unilabos_resources`   | ResourceSlot    | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅**物料**节点（不含设备）                |
-| `unilabos_devices`     | DeviceSlot      | `"/parent/device_name"`                               | 仅**设备**节点（type=device），路径字符串 |
-| `unilabos_nodes`       | NodeSlot        | `"/parent/node_name"`                                 | **设备 + 物料**，即所有节点，路径字符串   |
-| `unilabos_class`       | ClassSlot       | `"class_name"`                                        | 注册表中已上报的资源类 name               |
-| `unilabos_formulation` | FormulationSlot | `[{well_name, liquids: [{name, volume}]}]`            | 资源树中物料节点的 **name**，配合液体配方 |
-
-### ResourceSlot（`unilabos_resources`）
-
-最常见的类型。从资源树中选取**物料**节点（孔板、枪头盒、试剂槽等）：
-
-- 单个：`{"id": "/workstation/container1", "name": "container1", "uuid": "ff149a9a-..."}`
-- 数组：`[{"id": "/path/a", "name": "a", "uuid": "xxx"}, ...]`
-- `id` 从 parent 计算的路径格式，根据 action 语义选择正确的物料
-
-> **特例**：`create_resource` 的 `res_id`，目标物料可能尚不存在，直接填期望路径，不需要 uuid。
-
-### DeviceSlot / NodeSlot / ClassSlot
-
-- **DeviceSlot**（`unilabos_devices`）：路径字符串如 `"/host_node"`，仅 type=device 的节点
-- **NodeSlot**（`unilabos_nodes`）：路径字符串如 `"/PRCXI/PRCXI_Deck"`，设备 + 物料均可选
-- **ClassSlot**（`unilabos_class`）：类名字符串如 `"container"`，从 `req_resource_registry_upload.json` 查找
-
-### FormulationSlot（`unilabos_formulation`）
-
-描述**液体配方**：向哪些容器中加入哪些液体及体积。
-
-```json
-[
-  {
-    "sample_uuid": "",
-    "well_name": "bottle_A1",
-    "liquids": [{ "name": "LiPF6", "volume": 0.6 }]
-  }
-]
-```
-
-- `well_name` — 目标物料的 **name**（从资源树取，不是 `id` 路径）
-- `liquids[]` — 液体列表，每条含 `name`（试剂名）和 `volume`（体积，单位由上下文决定；pylabrobot 内部统一 uL）
-- `sample_uuid` — 样品 UUID，无样品传 `""`
-- 与 ResourceSlot 的区别：ResourceSlot 指向物料本身，FormulationSlot 引用物料名并附带配方信息
-
-### 通过 API #12 获取资源树
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
-```
-
-注意 `lab_uuid` 在路径中（不是查询参数）。返回结构：
-
-```json
-{
-  "code": 0,
-  "data": {
-    "nodes": [
-      {"name": "host_node", "uuid": "c3ec1e68-...", "type": "device", "parent": ""},
-      {"name": "PRCXI", "uuid": "e249c9a6-...", "type": "device", "parent": ""},
-      {"name": "PRCXI_Deck", "uuid": "fb6a8b71-...", "type": "deck", "parent": "PRCXI"}
-    ],
-    "edges": [...]
-  }
-}
-```
-
-- `data.nodes[]` — 所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`
-- `type` 区分设备（`device`）和物料（`deck`、`container`、`resource` 等）
-- `parent` 为父节点名称（空字符串表示顶级）
-- 填写 Slot 时根据 placeholder 类型筛选：ResourceSlot 取非 device 节点，DeviceSlot 取 device 节点
-- 创建/更新物料时：`parent_uuid` 取父节点的 `uuid`，更新目标的 `uuid` 取节点自身的 `uuid`
-
-## 物料管理 API
-
-设备 Skill 除了设备动作外，还需支持物料节点的创建和参数设定，用于在资源树中动态管理物料。
-
-典型流程：先通过 **#14 按名称查询模板** 获取 `res_template_uuid` → 再通过 **#15 创建物料** → 之后可通过 **#16 更新物料** 修改属性。更新时需要的 `uuid` 和 `parent_uuid` 均从 **#12 资源树下载** 获取。
-
-### API #14 — 按名称查询物料模板
-
-创建物料前，需要先获取物料模板的 UUID。通过模板名称查询：
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
-```
-
-| 参数       | 必填   | 说明                             |
-| ---------- | ------ | -------------------------------- |
-| `lab_uuid` | **是** | 实验室 UUID（从 API #1 获取）    |
-| `name`     | **是** | 物料模板名称（如 `"container"`） |
-
-返回 `code: 0` 时，**`data.uuid`** 即为 `res_template_uuid`，用于 API #15 创建物料。返回还包含 `name`、`resource_type`、`handles`、`config_infos` 等模板元信息。
-
-模板不存在时返回 `code: 10002`，`data` 为空对象。模板名称来自资源注册表中已注册的资源类型。
-
-### API #15 — 创建物料节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '<request_body>'
-```
-
-请求体：
-
-```json
-{
-  "res_template_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "name": "my_custom_bottle",
-  "display_name": "自定义瓶子",
-  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "type": "",
-  "init_param_data": {},
-  "schema": {},
-  "data": {
-    "liquids": [["water", 1000, "uL"]],
-    "max_volume": 50000
-  },
-  "plate_well_datas": {},
-  "plate_reagent_datas": {},
-  "pose": {},
-  "model": {}
-}
-```
-
-| 字段                  | 必填   | 类型          | 数据来源                            | 说明                                   |
-| --------------------- | ------ | ------------- | ----------------------------------- | -------------------------------------- |
-| `res_template_uuid`   | **是** | string (UUID) | **API #14** 按名称查询获取          | 物料模板 UUID                          |
-| `name`                | 否     | string        | **用户自定义**                      | 节点名称（标识符），可自由命名         |
-| `display_name`        | 否     | string        | 用户自定义                          | 显示名称（UI 展示用）                  |
-| `parent_uuid`         | 否     | string (UUID) | **API #12** 资源树中父节点的 `uuid` | 父节点，为空则创建顶级节点             |
-| `type`                | 否     | string        | 从模板继承                          | 节点类型                               |
-| `init_param_data`     | 否     | object        | 用户指定                            | 初始化参数，覆盖模板默认值             |
-| `data`                | 否     | object        | 用户指定                            | 节点数据，container 见下方 data 格式   |
-| `plate_well_datas`    | 否     | object        | 用户指定                            | 孔板子节点数据（创建带孔位的板时使用） |
-| `plate_reagent_datas` | 否     | object        | 用户指定                            | 试剂关联数据                           |
-| `schema`              | 否     | object        | 从模板继承                          | 自定义 schema，不传则从模板继承        |
-| `pose`                | 否     | object        | 用户指定                            | 位姿信息                               |
-| `model`               | 否     | object        | 用户指定                            | 3D 模型信息                            |
-
-#### container 的 `data` 格式
-
-> **体积单位统一为 uL（微升）**。pylabrobot 体系中所有体积值（`max_volume`、`liquids` 中的 volume）均为 uL。外部如果是 mL 需乘 1000 转换。
-
-```json
-{
-  "liquids": [["water", 1000, "uL"], ["ethanol", 500, "uL"]],
-  "max_volume": 50000
-}
-```
-
-- `liquids` — 液体列表，每条为 `[液体名称, 体积(uL), 单位字符串]`
-- `max_volume` — 容器最大容量（uL），如 50 mL = 50000 uL
-
-### API #16 — 更新物料节点
-
-```bash
-curl -s -X PUT "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '<request_body>'
-```
-
-请求体：
-
-```json
-{
-  "uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "parent_uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
-  "display_name": "新显示名称",
-  "description": "新描述",
-  "init_param_data": {},
-  "data": {},
-  "pose": {},
-  "schema": {},
-  "extra": {}
-}
-```
-
-| 字段              | 必填   | 类型          | 数据来源                              | 说明             |
-| ----------------- | ------ | ------------- | ------------------------------------- | ---------------- |
-| `uuid`            | **是** | string (UUID) | **API #12** 资源树中目标节点的 `uuid` | 要更新的物料节点 |
-| `parent_uuid`     | 否     | string (UUID) | API #12 资源树                        | 移动到新父节点   |
-| `display_name`    | 否     | string        | 用户指定                              | 更新显示名称     |
-| `description`     | 否     | string        | 用户指定                              | 更新描述         |
-| `init_param_data` | 否     | object        | 用户指定                              | 更新初始化参数   |
-| `data`            | 否     | object        | 用户指定                              | 更新节点数据     |
-| `pose`            | 否     | object        | 用户指定                              | 更新位姿         |
-| `schema`          | 否     | object        | 用户指定                              | 更新 schema      |
-| `extra`           | 否     | object        | 用户指定                              | 更新扩展数据     |
-
-> 只传需要更新的字段，未传的字段保持不变。
-
-## 最终目录结构
-
-```
-./<skill-name>/
-├── SKILL.md              # API 端点 + 渐进加载指引
-├── action-index.md       # 动作索引：描述/用途/核心参数
-└── actions/              # 每个 action 的完整 JSON Schema
-    ├── action1.json
-    ├── action2.json
-    └── ...
-```

.cursor/skills/create-device-skill/scripts/extract_device_actions.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-"""
-从 req_device_registry_upload.json 中提取指定设备的 action schema。
-
-用法:
-  # 列出所有设备及 action 数量（自动搜索注册表文件）
-  python extract_device_actions.py
-
-  # 指定注册表文件路径
-  python extract_device_actions.py --registry <path/to/req_device_registry_upload.json>
-
-  # 提取指定设备的 action 到目录
-  python extract_device_actions.py <device_id> <output_dir>
-  python extract_device_actions.py --registry <path> <device_id> <output_dir>
-
-示例:
-  python extract_device_actions.py --registry unilabos_data/req_device_registry_upload.json
-  python extract_device_actions.py liquid_handler.prcxi .cursor/skills/unilab-device-api/actions/
-"""
-import json
-import os
-import sys
-from datetime import datetime
-
-REGISTRY_FILENAME = "req_device_registry_upload.json"
-
-def find_registry(explicit_path=None):
-    """
-    查找 req_device_registry_upload.json 文件。
-
-    搜索优先级：
-    1. 用户通过 --registry 显式指定的路径
-    2. <cwd>/unilabos_data/req_device_registry_upload.json
-    3. <cwd>/req_device_registry_upload.json
-    4. <script所在目录>/../../.. (workspace根) 下的 unilabos_data/
-    5. 向上逐级搜索父目录（最多 5 层）
-    """
-    if explicit_path:
-        if os.path.isfile(explicit_path):
-            return explicit_path
-        if os.path.isdir(explicit_path):
-            fp = os.path.join(explicit_path, REGISTRY_FILENAME)
-            if os.path.isfile(fp):
-                return fp
-        print(f"警告: 指定的路径不存在: {explicit_path}")
-        return None
-
-    candidates = [
-        os.path.join("unilabos_data", REGISTRY_FILENAME),
-        REGISTRY_FILENAME,
-    ]
-
-    for c in candidates:
-        if os.path.isfile(c):
-            return c
-
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    workspace_root = os.path.normpath(os.path.join(script_dir, "..", "..", ".."))
-    for c in candidates:
-        path = os.path.join(workspace_root, c)
-        if os.path.isfile(path):
-            return path
-
-    cwd = os.getcwd()
-    for _ in range(5):
-        parent = os.path.dirname(cwd)
-        if parent == cwd:
-            break
-        cwd = parent
-        for c in candidates:
-            path = os.path.join(cwd, c)
-            if os.path.isfile(path):
-                return path
-
-    return None
-
-def load_registry(path):
-    with open(path, 'r', encoding='utf-8') as f:
-        return json.load(f)
-
-def list_devices(data):
-    """列出所有包含 action_value_mappings 的设备，同时返回 module 路径"""
-    resources = data.get('resources', [])
-    devices = []
-    for res in resources:
-        rid = res.get('id', '')
-        cls = res.get('class', {})
-        avm = cls.get('action_value_mappings', {})
-        module = cls.get('module', '')
-        if avm:
-            devices.append((rid, len(avm), module))
-    return devices
-
-def flatten_schema_to_goal(action_data):
-    """将 schema 中嵌套的 goal 内容提升为顶层 schema，去掉 feedback/result 包装"""
-    schema = action_data.get('schema', {})
-    goal_schema = schema.get('properties', {}).get('goal', {})
-    if goal_schema:
-        action_data = dict(action_data)
-        action_data['schema'] = goal_schema
-    return action_data
-
-
-def extract_actions(data, device_id, output_dir):
-    """提取指定设备的 action schema 到独立 JSON 文件"""
-    resources = data.get('resources', [])
-    for res in resources:
-        if res.get('id') == device_id:
-            cls = res.get('class', {})
-            module = cls.get('module', '')
-            avm = cls.get('action_value_mappings', {})
-            if not avm:
-                print(f"设备 {device_id} 没有 action_value_mappings")
-                return []
-
-            if module:
-                py_path = module.split(":")[0].replace(".", "/") + ".py"
-                class_name = module.split(":")[-1] if ":" in module else ""
-                print(f"Python 源码: {py_path}")
-                if class_name:
-                    print(f"设备类: {class_name}")
-
-            os.makedirs(output_dir, exist_ok=True)
-            written = []
-            for action_name in sorted(avm.keys()):
-                action_data = flatten_schema_to_goal(avm[action_name])
-                filename = action_name.replace('-', '_') + '.json'
-                filepath = os.path.join(output_dir, filename)
-                with open(filepath, 'w', encoding='utf-8') as f:
-                    json.dump(action_data, f, indent=2, ensure_ascii=False)
-                written.append(filename)
-                print(f"  {filepath}")
-            return written
-
-    print(f"设备 {device_id} 未找到")
-    return []
-
-def main():
-    args = sys.argv[1:]
-    explicit_registry = None
-
-    if "--registry" in args:
-        idx = args.index("--registry")
-        if idx + 1 < len(args):
-            explicit_registry = args[idx + 1]
-            args = args[:idx] + args[idx + 2:]
-        else:
-            print("错误: --registry 需要指定路径")
-            sys.exit(1)
-
-    registry_path = find_registry(explicit_registry)
-    if not registry_path:
-        print(f"错误: 找不到 {REGISTRY_FILENAME}")
-        print()
-        print("解决方法:")
-        print("  1. 先运行 unilab 启动命令，等待注册表生成")
-        print("  2. 用 --registry 指定文件路径:")
-        print(f"     python {sys.argv[0]} --registry <path/to/{REGISTRY_FILENAME}>")
-        print()
-        print("搜索过的路径:")
-        for p in [
-            os.path.join("unilabos_data", REGISTRY_FILENAME),
-            REGISTRY_FILENAME,
-            os.path.join("<workspace_root>", "unilabos_data", REGISTRY_FILENAME),
-        ]:
-            print(f"  - {p}")
-        sys.exit(1)
-
-    print(f"注册表: {registry_path}")
-    mtime = os.path.getmtime(registry_path)
-    gen_time = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
-    size_mb = os.path.getsize(registry_path) / (1024 * 1024)
-    print(f"生成时间: {gen_time}  (文件大小: {size_mb:.1f} MB)")
-    data = load_registry(registry_path)
-
-    if len(args) == 0:
-        devices = list_devices(data)
-        print(f"\n找到 {len(devices)} 个设备:")
-        print(f"{'设备 ID':<50} {'Actions':>7}  {'Python 模块'}")
-        print("-" * 120)
-        for did, count, module in sorted(devices, key=lambda x: x[0]):
-            py_path = module.split(":")[0].replace(".", "/") + ".py" if module else ""
-            print(f"{did:<50} {count:>7}  {py_path}")
-
-    elif len(args) == 2:
-        device_id = args[0]
-        output_dir = args[1]
-        print(f"\n提取 {device_id} 的 actions 到 {output_dir}/")
-        written = extract_actions(data, device_id, output_dir)
-        if written:
-            print(f"\n共写入 {len(written)} 个 action 文件")
-
-    else:
-        print("用法:")
-        print("  python extract_device_actions.py [--registry <path>]                # 列出设备")
-        print("  python extract_device_actions.py [--registry <path>] <device_id> <dir>  # 提取 actions")
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main()

.cursor/skills/create-device-skill/scripts/gen_auth.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-"""
-从 ak/sk 生成 UniLab API Authorization header。
-
-算法: base64(ak:sk) → "Authorization: Lab <token>"
-
-用法:
-  python gen_auth.py <ak> <sk>
-  python gen_auth.py --config <config.py>
-
-示例:
-  python gen_auth.py myak mysk
-  python gen_auth.py --config experiments/config.py
-"""
-import base64
-import re
-import sys
-
-
-def gen_auth(ak: str, sk: str) -> str:
-    token = base64.b64encode(f"{ak}:{sk}".encode("utf-8")).decode("utf-8")
-    return token
-
-
-def extract_from_config(config_path: str) -> tuple:
-    """从 config.py 中提取 ak 和 sk"""
-    with open(config_path, "r", encoding="utf-8") as f:
-        content = f.read()
-    ak_match = re.search(r'''ak\s*=\s*["']([^"']+)["']''', content)
-    sk_match = re.search(r'''sk\s*=\s*["']([^"']+)["']''', content)
-    if not ak_match or not sk_match:
-        return None, None
-    return ak_match.group(1), sk_match.group(1)
-
-
-def main():
-    args = sys.argv[1:]
-
-    if len(args) == 2 and args[0] == "--config":
-        ak, sk = extract_from_config(args[1])
-        if not ak or not sk:
-            print(f"错误: 在 {args[1]} 中未找到 ak/sk 配置")
-            print("期望格式: ak = \"xxx\"  sk = \"xxx\"")
-            sys.exit(1)
-        print(f"配置文件: {args[1]}")
-    elif len(args) == 2:
-        ak, sk = args
-    else:
-        print("用法:")
-        print("  python gen_auth.py <ak> <sk>")
-        print("  python gen_auth.py --config <config.py>")
-        sys.exit(1)
-
-    token = gen_auth(ak, sk)
-    print(f"ak: {ak}")
-    print(f"sk: {sk}")
-    print()
-    print(f"Authorization header:")
-    print(f"  Authorization: Lab {token}")
-    print()
-    print(f"curl 用法:")
-    print(f'  curl -H "Authorization: Lab {token}" ...')
-    print()
-    print(f"Shell 变量:")
-    print(f'  AUTH="Authorization: Lab {token}"')
-
-
-if __name__ == "__main__":
-    main()

.cursor/skills/host-node/SKILL.md

@@ -1,251 +0,0 @@
----
-name: host-node
-description: Operate Uni-Lab host node via REST API — create resources, test latency, test resource tree, manual confirm. Use when the user mentions host_node, creating resources, resource management, testing latency, or any host node operation.
----
-
-# Host Node API Skill
-
-## 设备信息
-
-- **device_id**: `host_node`
-- **Python 源码**: `unilabos/ros/nodes/presets/host_node.py`
-- **设备类**: `HostNode`
-- **动作数**: 4（`create_resource`, `test_latency`, `auto-test_resource`, `manual_confirm`）
-
-## 前置条件（缺一不可）
-
-使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
-
-### 2. --addr → BASE URL
-
-| `--addr` 值  | BASE                                |
-| ------------ | ----------------------------------- |
-| `test`       | `https://leap-lab.test.bohrium.com` |
-| `uat`        | `https://leap-lab.uat.bohrium.com`  |
-| `local`      | `http://127.0.0.1:48197`            |
-| 不传（默认） | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-AUTH="Authorization: Lab <token>"
-```
-
-**两项全部就绪后才可发起 API 请求。**
-
-## Session State
-
-在整个对话过程中，agent 需要记住以下状态，避免重复询问用户：
-
-- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
-- `device_name` — `host_node`
-
-## 请求约定
-
-所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
-
-> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
-
----
-
-## API Endpoints
-
-### 1. 获取实验室信息（自动获取 lab_uuid）
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
-
-### 2. 创建工作流
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
-```
-
-返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
-
-### 3. 创建节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"host_node","node_template_name":"<action_name>"}'
-```
-
-- `resource_template_name` 固定为 `host_node`
-- `node_template_name` — action 名称（如 `create_resource`, `test_latency`）
-
-### 4. 删除节点
-
-```bash
-curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
-```
-
-### 5. 更新节点参数
-
-```bash
-curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
-```
-
-`param` 直接使用创建节点返回的 `data.param` 结构，修改需要填入的字段值。参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
-
-### 6. 查询节点 handles
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
-```
-
-### 7. 批量创建边
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
-```
-
-### 8. 启动工作流
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
-```
-
-### 9. 运行设备单动作
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"lab_uuid":"<lab_uuid>","device_id":"host_node","action":"<action_name>","action_type":"<type>","param":{...}}'
-```
-
-`param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
-
-> **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
-
-#### action_type 速查表
-
-| action | action_type |
-|--------|-------------|
-| `test_latency` | `UniLabJsonCommand` |
-| `create_resource` | `ResourceCreateFromOuterEasy` |
-| `auto-test_resource` | `UniLabJsonCommand` |
-| `manual_confirm` | `UniLabJsonCommand` |
-
-### 10. 查询任务状态
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
-```
-
-### 11. 运行工作流单节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuid":"<node_uuid>"}'
-```
-
-### 12. 获取资源树（物料信息）
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
-```
-
-注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
-
-### 13. 获取工作流模板详情
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
-```
-
-> 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
-
-### 14. 按名称查询物料模板
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
-```
-
-返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
-
-### 15. 创建物料节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
-```
-
-### 16. 更新物料节点
-
-```bash
-curl -s -X PUT "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
-```
-
----
-
-## Placeholder Slot 填写规则
-
-| `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
-| --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
-| `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
-| `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
-| `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
-| `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
-
-### host_node 设备的 Slot 字段表
-
-| Action            | 字段        | Slot 类型    | 说明                           |
-| ----------------- | ----------- | ------------ | ------------------------------ |
-| `create_resource` | `res_id`    | ResourceSlot | 新资源路径（可填不存在的路径） |
-| `create_resource` | `device_id` | DeviceSlot   | 归属设备                       |
-| `create_resource` | `parent`    | NodeSlot     | 父节点路径                     |
-| `create_resource` | `class_name`| ClassSlot    | 资源类名如 `"container"`       |
-| `auto-test_resource` | `resource`  | ResourceSlot | 单个测试物料                |
-| `auto-test_resource` | `resources` | ResourceSlot | 测试物料数组                |
-| `auto-test_resource` | `device`    | DeviceSlot   | 测试设备                    |
-| `auto-test_resource` | `devices`   | DeviceSlot   | 测试设备                    |
-
----
-
-## 渐进加载策略
-
-1. **SKILL.md**（本文件）— API 端点 + session state 管理
-2. **[action-index.md](action-index.md)** — 按分类浏览 4 个动作的描述和核心参数
-3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
-- [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
-- [ ] Step 3: 读 action-index.md 确定要用的 action 名
-- [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
-- [ ] Step 5: 创建节点 (POST #3, resource_template_name=host_node) → 记住 node_uuid + data.param
-- [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
-- [ ] Step 7: 更新节点参数 (PATCH #5)
-- [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
-- [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
-- [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
-- [ ] Step 11: 查询任务状态 (GET #10) 确认完成
-```

.cursor/skills/host-node/action-index.md

@@ -1,58 +0,0 @@
-# Action Index — host_node
-
-4 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
-
----
-
-## 资源管理
-
-### `create_resource`
-
-在资源树中创建新资源（容器、物料等），支持指定位置、类型和初始液体
-
-- **action_type**: `ResourceCreateFromOuterEasy`
-- **Schema**: [`actions/create_resource.json`](actions/create_resource.json)
-- **可选参数**: `res_id`, `device_id`, `class_name`, `parent`, `bind_locations`, `liquid_input_slot`, `liquid_type`, `liquid_volume`, `slot_on_deck`
-- **占位符字段**:
-  - `res_id` — **ResourceSlot**（特例：目标物料可能尚不存在，直接填期望路径）
-  - `device_id` — **DeviceSlot**，填路径字符串如 `"/host_node"`
-  - `parent` — **NodeSlot**，填路径字符串如 `"/workstation/deck"`
-  - `class_name` — **ClassSlot**，填类名如 `"container"`
-
-### `auto-test_resource`
-
-测试资源系统，返回当前资源树和设备列表
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/test_resource.json`](actions/test_resource.json)
-- **可选参数**: `resource`, `resources`, `device`, `devices`
-- **占位符字段**:
-  - `resource` — **ResourceSlot**，单个物料节点 `{id, name, uuid}`
-  - `resources` — **ResourceSlot**，物料节点数组 `[{id, name, uuid}, ...]`
-  - `device` — **DeviceSlot**，设备路径字符串
-  - `devices` — **DeviceSlot**，设备路径字符串
-
----
-
-## 系统工具
-
-### `test_latency`
-
-测试设备通信延迟，返回 RTT、时间差、任务延迟等指标
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/test_latency.json`](actions/test_latency.json)
-- **参数**: 无（零参数调用）
-
----
-
-## 人工确认
-
-### `manual_confirm`
-
-创建人工确认节点，等待用户手动确认后继续
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
-- **核心参数**: `timeout_seconds`（超时时间，秒）, `assignee_user_ids`（指派用户 ID 列表）
-- **占位符字段**: `assignee_user_ids` — `unilabos_manual_confirm` 类型

.cursor/skills/host-node/actions/create_resource.json

@@ -1,93 +0,0 @@
-{
-  "type": "ResourceCreateFromOuterEasy",
-  "goal": {
-    "res_id": "res_id",
-    "class_name": "class_name",
-    "parent": "parent",
-    "device_id": "device_id",
-    "bind_locations": "bind_locations",
-    "liquid_input_slot": "liquid_input_slot[]",
-    "liquid_type": "liquid_type[]",
-    "liquid_volume": "liquid_volume[]",
-    "slot_on_deck": "slot_on_deck"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "res_id": {
-        "type": "string"
-      },
-      "device_id": {
-        "type": "string"
-      },
-      "class_name": {
-        "type": "string"
-      },
-      "parent": {
-        "type": "string"
-      },
-      "bind_locations": {
-        "type": "object",
-        "properties": {
-          "x": {
-            "type": "number",
-            "minimum": -1.7976931348623157e+308,
-            "maximum": 1.7976931348623157e+308
-          },
-          "y": {
-            "type": "number",
-            "minimum": -1.7976931348623157e+308,
-            "maximum": 1.7976931348623157e+308
-          },
-          "z": {
-            "type": "number",
-            "minimum": -1.7976931348623157e+308,
-            "maximum": 1.7976931348623157e+308
-          }
-        },
-        "required": [
-          "x",
-          "y",
-          "z"
-        ],
-        "title": "bind_locations",
-        "additionalProperties": false
-      },
-      "liquid_input_slot": {
-        "type": "array",
-        "items": {
-          "type": "integer"
-        }
-      },
-      "liquid_type": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        }
-      },
-      "liquid_volume": {
-        "type": "array",
-        "items": {
-          "type": "number"
-        }
-      },
-      "slot_on_deck": {
-        "type": "string"
-      }
-    },
-    "required": [],
-    "_unilabos_placeholder_info": {
-      "res_id": "unilabos_resources",
-      "device_id": "unilabos_devices",
-      "parent": "unilabos_nodes",
-      "class_name": "unilabos_class"
-    }
-  },
-  "goal_default": {},
-  "placeholder_keys": {
-    "res_id": "unilabos_resources",
-    "device_id": "unilabos_devices",
-    "parent": "unilabos_nodes",
-    "class_name": "unilabos_class"
-  }
-}

.cursor/skills/host-node/actions/manual_confirm.json

@@ -1,32 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "timeout_seconds": "timeout_seconds",
-    "assignee_user_ids": "assignee_user_ids"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "timeout_seconds": {
-        "type": "integer"
-      },
-      "assignee_user_ids": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        }
-      }
-    },
-    "required": [
-      "timeout_seconds",
-      "assignee_user_ids"
-    ],
-    "_unilabos_placeholder_info": {
-      "assignee_user_ids": "unilabos_manual_confirm"
-    }
-  },
-  "goal_default": {},
-  "placeholder_keys": {
-    "assignee_user_ids": "unilabos_manual_confirm"
-  }
-}

.cursor/skills/host-node/actions/test_latency.json

@@ -1,11 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {},
-  "schema": {
-    "type": "object",
-    "properties": {},
-    "required": []
-  },
-  "goal_default": {},
-  "placeholder_keys": {}
-}

.cursor/skills/host-node/actions/test_resource.json

@@ -1,255 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "resource": "resource",
-    "resources": "resources",
-    "device": "device",
-    "devices": "devices"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "resource": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          },
-          "sample_id": {
-            "type": "string"
-          },
-          "children": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "parent": {
-            "type": "string"
-          },
-          "type": {
-            "type": "string"
-          },
-          "category": {
-            "type": "string"
-          },
-          "pose": {
-            "type": "object",
-            "properties": {
-              "position": {
-                "type": "object",
-                "properties": {
-                  "x": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  },
-                  "y": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  },
-                  "z": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  }
-                },
-                "required": [
-                  "x",
-                  "y",
-                  "z"
-                ],
-                "title": "position",
-                "additionalProperties": false
-              },
-              "orientation": {
-                "type": "object",
-                "properties": {
-                  "x": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  },
-                  "y": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  },
-                  "z": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  },
-                  "w": {
-                    "type": "number",
-                    "minimum": -1.7976931348623157e+308,
-                    "maximum": 1.7976931348623157e+308
-                  }
-                },
-                "required": [
-                  "x",
-                  "y",
-                  "z",
-                  "w"
-                ],
-                "title": "orientation",
-                "additionalProperties": false
-              }
-            },
-            "required": [
-              "position",
-              "orientation"
-            ],
-            "title": "pose",
-            "additionalProperties": false
-          },
-          "config": {
-            "type": "string"
-          },
-          "data": {
-            "type": "string"
-          }
-        },
-        "title": "resource"
-      },
-      "resources": {
-        "items": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sample_id": {
-              "type": "string"
-            },
-            "children": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "parent": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string"
-            },
-            "category": {
-              "type": "string"
-            },
-            "pose": {
-              "type": "object",
-              "properties": {
-                "position": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z"
-                  ],
-                  "title": "position",
-                  "additionalProperties": false
-                },
-                "orientation": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "w": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z",
-                    "w"
-                  ],
-                  "title": "orientation",
-                  "additionalProperties": false
-                }
-              },
-              "required": [
-                "position",
-                "orientation"
-              ],
-              "title": "pose",
-              "additionalProperties": false
-            },
-            "config": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
-            }
-          },
-          "title": "resources"
-        },
-        "type": "array"
-      },
-      "device": {
-        "type": "string",
-        "description": "device reference"
-      },
-      "devices": {
-        "type": "string",
-        "description": "device reference"
-      }
-    },
-    "required": [],
-    "_unilabos_placeholder_info": {
-      "resource": "unilabos_resources",
-      "resources": "unilabos_resources",
-      "device": "unilabos_devices",
-      "devices": "unilabos_devices"
-    }
-  },
-  "goal_default": {},
-  "placeholder_keys": {
-    "resource": "unilabos_resources",
-    "resources": "unilabos_resources",
-    "device": "unilabos_devices",
-    "devices": "unilabos_devices"
-  }
-}

.cursor/skills/submit-agent-result/SKILL.md

@@ -1,284 +0,0 @@
----
-name: submit-agent-result
-description: Submit historical experiment results (agent_result) to Uni-Lab cloud platform (leap-lab) notebook — read data files, assemble JSON payload, PUT to cloud API. Use when the user wants to submit experiment results, upload agent results, report experiment data, or mentions agent_result/实验结果/历史记录/notebook结果.
----
-
-# Uni-Lab 提交历史实验记录指南
-
-通过 Uni-Lab 云端 API 向已创建的 notebook 提交实验结果数据（agent_result）。支持从 JSON / CSV 文件读取数据，整合后提交。
-
-> **重要**：本指南中的 `Authorization: Lab <token>` 是 **Uni-Lab 平台专用的认证方式**，`Lab` 是 Uni-Lab 的 auth scheme 关键字，**不是** HTTP Basic 认证。请勿将其替换为 `Basic`。
-
-## 前置条件（缺一不可）
-
-使用本指南前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-询问用户的启动参数，从 `--ak` `--sk` 或 config.py 中获取。
-
-生成 AUTH token：
-
-```bash
-# ⚠️ 注意：scheme 是 "Lab"（Uni-Lab 专用），不是 "Basic"
-python -c "import base64,sys; print(base64.b64encode(f'{sys.argv[1]}:{sys.argv[2]}'.encode()).decode())" <ak> <sk>
-```
-
-输出即为 token 值，拼接为 `Authorization: Lab <token>`（`Lab` 是 Uni-Lab 平台 auth scheme，不可替换为 `Basic`）。
-
-### 2. --addr → BASE URL
-
-| `--addr` 值  | BASE                                |
-| ------------ | ----------------------------------- |
-| `test`       | `https://leap-lab.test.bohrium.com` |
-| `uat`        | `https://leap-lab.uat.bohrium.com`  |
-| `local`      | `http://127.0.0.1:48197`            |
-| 不传（默认） | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-# ⚠️ Auth scheme 必须是 "Lab"（Uni-Lab 专用），不是 "Basic"
-AUTH="Authorization: Lab <上面命令输出的 token>"
-```
-
-### 3. notebook_uuid（**必须询问用户**）
-
-**必须主动询问用户**：「请提供要提交结果的 notebook UUID。」
-
-notebook_uuid 来自之前通过「批量提交实验」创建的实验批次，即 `POST /api/v1/lab/notebook` 返回的 `data.uuid`。
-
-如果用户不记得，可提示：
-
-- 查看之前的对话记录中创建 notebook 时返回的 UUID
-- 或通过平台页面查找对应的 notebook
-
-**绝不能跳过此步骤，没有 notebook_uuid 无法提交。**
-
-### 4. 实验结果数据
-
-用户需要提供实验结果数据，支持以下方式：
-
-| 方式      | 说明                                            |
-| --------- | ----------------------------------------------- |
-| JSON 文件 | 直接作为 `agent_result` 的内容合并              |
-| CSV 文件  | 转为 `{"文件名": [行数据...]}` 格式             |
-| 手动指定  | 用户直接告知 key-value 数据，由 agent 构建 JSON |
-
-**四项全部就绪后才可开始。**
-
-## Session State
-
-在整个对话过程中，agent 需要记住以下状态：
-
-- `lab_uuid` — 实验室 UUID（通过 API #1 自动获取，**不需要问用户**）
-- `notebook_uuid` — 目标 notebook UUID（**必须询问用户**）
-
-## 请求约定
-
-所有请求使用 `curl -s`，PUT 需加 `Content-Type: application/json`。
-
-> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名），示例中的 `curl` 均指 `curl.exe`。
->
-> **PowerShell JSON 传参**：PowerShell 中 `-d '{"key":"value"}'` 会因引号转义失败。请将 JSON 写入临时文件，用 `-d '@tmp_body.json'`（单引号包裹 `@`，否则 `@` 会被 PowerShell 解析为 splatting 运算符导致报错）。
-
----
-
-## API Endpoints
-
-### 1. 获取实验室信息（自动获取 lab_uuid）
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回：
-
-```json
-{ "code": 0, "data": { "uuid": "xxx", "name": "实验室名称" } }
-```
-
-记住 `data.uuid` 为 `lab_uuid`。
-
-### 2. 提交实验结果（agent_result）
-
-```bash
-curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '<request_body>'
-```
-
-请求体结构：
-
-```json
-{
-    "notebook_uuid": "<notebook_uuid>",
-    "agent_result": {
-        "<key1>": "<value1>",
-        "<key2>": 123,
-        "<nested_key>": {"a": 1, "b": 2},
-        "<array_key>": [{"col1": "v1", "col2": "v2"}, ...]
-    }
-}
-```
-
-> **注意**：HTTP 方法是 **PUT**（不是 POST）。
-
-#### 必要字段
-
-| 字段            | 类型          | 说明                                        |
-| --------------- | ------------- | ------------------------------------------- |
-| `notebook_uuid` | string (UUID) | 目标 notebook 的 UUID，从批量提交实验时获取 |
-| `agent_result`  | object        | 实验结果数据，任意 JSON 对象                |
-
-#### agent_result 内容格式
-
-`agent_result` 接受**任意 JSON 对象**，常见格式：
-
-**简单键值对**：
-
-```json
-{
-  "avg_rtt_ms": 12.5,
-  "status": "success",
-  "test_count": 5
-}
-```
-
-**包含嵌套结构**：
-
-```json
-{
-  "summary": { "total": 100, "passed": 98, "failed": 2 },
-  "measurements": [
-    { "sample_id": "S001", "value": 3.14, "unit": "mg/mL" },
-    { "sample_id": "S002", "value": 2.71, "unit": "mg/mL" }
-  ]
-}
-```
-
-**从 CSV 文件导入**（脚本自动转换）：
-
-```json
-{
-  "experiment_data": [
-    { "温度": 25, "压力": 101.3, "产率": 0.85 },
-    { "温度": 30, "压力": 101.3, "产率": 0.91 }
-  ]
-}
-```
-
----
-
-## 整合脚本
-
-本文档同级目录下的 `scripts/prepare_agent_result.py` 可自动读取文件并构建请求体。
-
-### 用法
-
-```bash
-python scripts/prepare_agent_result.py \
-    --notebook-uuid <uuid> \
-    --files data1.json data2.csv \
-    [--auth <token>] \
-    [--base <BASE_URL>] \
-    [--submit] \
-    [--output <output.json>]
-```
-
-| 参数              | 必选       | 说明                                            |
-| ----------------- | ---------- | ----------------------------------------------- |
-| `--notebook-uuid` | 是         | 目标 notebook UUID                              |
-| `--files`         | 是         | 输入文件路径（支持多个，JSON / CSV）            |
-| `--auth`          | 提交时必选 | Lab token（base64(ak:sk)）                      |
-| `--base`          | 提交时必选 | API base URL                                    |
-| `--submit`        | 否         | 加上此标志则直接提交到云端                      |
-| `--output`        | 否         | 输出 JSON 路径（默认 `agent_result_body.json`） |
-
-### 文件合并规则
-
-| 文件类型              | 合并方式                                     |
-| --------------------- | -------------------------------------------- |
-| `.json`（dict）       | 字段直接合并到 `agent_result` 顶层           |
-| `.json`（list/other） | 以文件名为 key 放入 `agent_result`           |
-| `.csv`                | 以文件名（不含扩展名）为 key，值为行对象数组 |
-
-多个文件的字段会合并。JSON dict 中的重复 key 后者覆盖前者。
-
-### 示例
-
-```bash
-# 仅生成请求体文件（不提交）
-python scripts/prepare_agent_result.py \
-    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
-    --files results.json measurements.csv
-
-# 生成并直接提交
-python scripts/prepare_agent_result.py \
-    --notebook-uuid 73c67dca-c8cc-4936-85a0-329106aa7cca \
-    --files results.json \
-    --auth YTFmZDlkNGUt... \
-    --base https://leap-lab.test.bohrium.com \
-    --submit
-```
-
----
-
-## 手动构建方式
-
-如果不使用脚本，也可手动构建请求体：
-
-1. 将实验结果数据组装为 JSON 对象
-2. 写入临时文件：
-
-```json
-{
-    "notebook_uuid": "<uuid>",
-    "agent_result": { ... }
-}
-```
-
-3. 用 curl 提交：
-
-```bash
-curl -s -X PUT "$BASE/api/v1/lab/notebook/agent-result" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '@tmp_body.json'
-```
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 1: 确认 ak/sk → 生成 AUTH token
-- [ ] Step 2: 确认 --addr → 设置 BASE URL
-- [ ] Step 3: GET /edge/lab/info → 获取 lab_uuid
-- [ ] Step 4: **询问用户** notebook_uuid（必须，不可跳过）
-- [ ] Step 5: 确认实验结果数据来源（文件路径或手动数据）
-- [ ] Step 6: 运行 prepare_agent_result.py 或手动构建请求体
-- [ ] Step 7: PUT /lab/notebook/agent-result 提交
-- [ ] Step 8: 检查返回结果，确认提交成功
-```
-
----
-
-## 常见问题
-
-### Q: notebook_uuid 从哪里获取？
-
-从之前「批量提交实验」时 `POST /api/v1/lab/notebook` 的返回值 `data.uuid` 获取。也可以在平台 UI 中查找对应的 notebook。
-
-### Q: agent_result 有固定的 schema 吗？
-
-没有严格 schema，接受任意 JSON 对象。但建议包含有意义的字段名和结构化数据，方便后续分析。
-
-### Q: 可以多次提交同一个 notebook 的结果吗？
-
-可以，后续提交会覆盖之前的 agent_result。
-
-### Q: 认证方式是 Lab 还是 Api？
-
-本指南统一使用 `Authorization: Lab <base64(ak:sk)>` 方式（`Lab` 是 Uni-Lab 平台的 auth scheme，**绝不能用 `Basic` 替代**）。如果用户有独立的 API Key，也可用 `Authorization: Api <key>` 替代。

.cursor/skills/submit-agent-result/scripts/prepare_agent_result.py

@@ -1,133 +0,0 @@
-"""
-读取实验结果文件（JSON / CSV），整合为 agent_result 请求体并可选提交。
-
-用法:
-    python prepare_agent_result.py \
-        --notebook-uuid <uuid> \
-        --files data1.json data2.csv \
-        [--auth <Lab token>] \
-        [--base <BASE_URL>] \
-        [--submit] \
-        [--output <output.json>]
-
-支持的输入文件格式:
-    - .json  → 直接作为 dict 合并
-    - .csv   → 转为 {"filename": [row_dict, ...]} 格式
-"""
-
-import argparse
-import base64
-import csv
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-def read_json_file(filepath: str) -> Dict[str, Any]:
-    with open(filepath, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def read_csv_file(filepath: str) -> List[Dict[str, Any]]:
-    rows = []
-    with open(filepath, "r", encoding="utf-8-sig") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            converted = {}
-            for k, v in row.items():
-                try:
-                    converted[k] = int(v)
-                except (ValueError, TypeError):
-                    try:
-                        converted[k] = float(v)
-                    except (ValueError, TypeError):
-                        converted[k] = v
-            rows.append(converted)
-    return rows
-
-
-def merge_files(filepaths: List[str]) -> Dict[str, Any]:
-    """将多个文件合并为一个 agent_result dict"""
-    merged: Dict[str, Any] = {}
-    for fp in filepaths:
-        path = Path(fp)
-        ext = path.suffix.lower()
-        key = path.stem
-
-        if ext == ".json":
-            data = read_json_file(fp)
-            if isinstance(data, dict):
-                merged.update(data)
-            else:
-                merged[key] = data
-        elif ext == ".csv":
-            merged[key] = read_csv_file(fp)
-        else:
-            print(f"[警告] 不支持的文件格式: {fp}，跳过", file=sys.stderr)
-
-    return merged
-
-
-def build_request_body(notebook_uuid: str, agent_result: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "notebook_uuid": notebook_uuid,
-        "agent_result": agent_result,
-    }
-
-
-def submit(base: str, auth: str, body: Dict[str, Any]) -> Dict[str, Any]:
-    try:
-        import requests
-    except ImportError:
-        print("[错误] 提交需要 requests 库: pip install requests", file=sys.stderr)
-        sys.exit(1)
-
-    url = f"{base}/api/v1/lab/notebook/agent-result"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Lab {auth}",
-    }
-    resp = requests.put(url, json=body, headers=headers, timeout=30)
-    return {"status_code": resp.status_code, "body": resp.json() if resp.headers.get("content-type", "").startswith("application/json") else resp.text}
-
-
-def main():
-    parser = argparse.ArgumentParser(description="整合实验结果文件并构建 agent_result 请求体")
-    parser.add_argument("--notebook-uuid", required=True, help="目标 notebook UUID")
-    parser.add_argument("--files", nargs="+", required=True, help="输入文件路径（JSON / CSV）")
-    parser.add_argument("--auth", help="Lab token（base64(ak:sk)）")
-    parser.add_argument("--base", help="API base URL")
-    parser.add_argument("--submit", action="store_true", help="直接提交到云端")
-    parser.add_argument("--output", default="agent_result_body.json", help="输出 JSON 文件路径")
-
-    args = parser.parse_args()
-
-    for fp in args.files:
-        if not os.path.exists(fp):
-            print(f"[错误] 文件不存在: {fp}", file=sys.stderr)
-            sys.exit(1)
-
-    agent_result = merge_files(args.files)
-    body = build_request_body(args.notebook_uuid, agent_result)
-
-    with open(args.output, "w", encoding="utf-8") as f:
-        json.dump(body, f, ensure_ascii=False, indent=2)
-    print(f"[完成] 请求体已保存: {args.output}")
-    print(f"  notebook_uuid: {args.notebook_uuid}")
-    print(f"  agent_result 字段数: {len(agent_result)}")
-    print(f"  合并文件数: {len(args.files)}")
-
-    if args.submit:
-        if not args.auth or not args.base:
-            print("[错误] 提交需要 --auth 和 --base 参数", file=sys.stderr)
-            sys.exit(1)
-        print(f"\n[提交] PUT {args.base}/api/v1/lab/notebook/agent-result ...")
-        result = submit(args.base, args.auth, body)
-        print(f"  HTTP {result['status_code']}")
-        print(f"  响应: {json.dumps(result['body'], ensure_ascii=False)}")
-
-
-if __name__ == "__main__":
-    main()

.cursor/skills/virtual-workbench/SKILL.md

@@ -1,272 +0,0 @@
----
-name: virtual-workbench
-description: Operate Virtual Workbench via REST API — prepare materials, move to heating stations, start heating, move to output, transfer resources. Use when the user mentions virtual workbench, virtual_workbench, 虚拟工作台, heating stations, material processing, or workbench operations.
----
-
-# Virtual Workbench API Skill
-
-## 设备信息
-
-- **device_id**: `virtual_workbench`
-- **Python 源码**: `unilabos/devices/virtual/workbench.py`
-- **设备类**: `VirtualWorkbench`
-- **动作数**: 6（`auto-prepare_materials`, `auto-move_to_heating_station`, `auto-start_heating`, `auto-move_to_output`, `transfer`, `manual_confirm`）
-- **设备描述**: 模拟工作台，包含 1 个机械臂（每次操作 2s，独占锁）和 3 个加热台（每次加热 60s，可并行）
-
-### 典型工作流程
-
-1. `prepare_materials` — 生成 A1-A5 物料（5 个 output handle）
-2. `move_to_heating_station` — 物料并发竞争机械臂，移动到空闲加热台
-3. `start_heating` — 启动加热（3 个加热台可并行）
-4. `move_to_output` — 加热完成后移到输出位置 Cn
-
-## 前置条件（缺一不可）
-
-使用本 skill 前，**必须**先确认以下信息。如果缺少任何一项，**立即向用户询问并终止**，等补齐后再继续。
-
-### 1. ak / sk → AUTH
-
-从启动参数 `--ak` `--sk` 或 config.py 中获取，生成 token：`base64(ak:sk)` → `Authorization: Lab <token>`
-
-### 2. --addr → BASE URL
-
-| `--addr` 值  | BASE                                |
-| ------------ | ----------------------------------- |
-| `test`       | `https://leap-lab.test.bohrium.com` |
-| `uat`        | `https://leap-lab.uat.bohrium.com`  |
-| `local`      | `http://127.0.0.1:48197`            |
-| 不传（默认） | `https://leap-lab.bohrium.com`      |
-
-确认后设置：
-
-```bash
-BASE="<根据 addr 确定的 URL>"
-AUTH="Authorization: Lab <token>"
-```
-
-**两项全部就绪后才可发起 API 请求。**
-
-## Session State
-
-- `lab_uuid` — 实验室 UUID（首次通过 API #1 自动获取，**不需要问用户**）
-- `device_name` — `virtual_workbench`
-
-## 请求约定
-
-所有请求使用 `curl -s`，POST/PATCH/DELETE 需加 `Content-Type: application/json`。
-
-> **Windows 平台**必须使用 `curl.exe`（而非 PowerShell 的 `curl` 别名）。
-
----
-
-## API Endpoints
-
-### 1. 获取实验室信息（自动获取 lab_uuid）
-
-```bash
-curl -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-```
-
-返回 `data.uuid` 为 `lab_uuid`，`data.name` 为 `lab_name`。
-
-### 2. 创建工作流
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/owner" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"name":"<名称>","lab_uuid":"<lab_uuid>","description":"<描述>"}'
-```
-
-返回 `data.uuid` 为 `workflow_uuid`。创建成功后告知用户链接：`$BASE/laboratory/$lab_uuid/workflow/$workflow_uuid`
-
-### 3. 创建节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/edge/workflow/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"workflow_uuid":"<workflow_uuid>","resource_template_name":"virtual_workbench","node_template_name":"<action_name>"}'
-```
-
-- `resource_template_name` 固定为 `virtual_workbench`
-- `node_template_name` — action 名称（如 `auto-prepare_materials`, `auto-move_to_heating_station`）
-
-### 4. 删除节点
-
-```bash
-curl -s -X DELETE "$BASE/api/v1/lab/workflow/nodes" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuids":["<uuid1>"],"workflow_uuid":"<workflow_uuid>"}'
-```
-
-### 5. 更新节点参数
-
-```bash
-curl -s -X PATCH "$BASE/api/v1/lab/workflow/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"workflow_uuid":"<wf_uuid>","uuid":"<node_uuid>","param":{...}}'
-```
-
-参考 [action-index.md](action-index.md) 确定哪些字段是 Slot。
-
-### 6. 查询节点 handles
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/node-handles" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuids":["<node_uuid_1>","<node_uuid_2>"]}'
-```
-
-### 7. 批量创建边
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/edges" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"edges":[{"source_node_uuid":"<uuid>","target_node_uuid":"<uuid>","source_handle_uuid":"<uuid>","target_handle_uuid":"<uuid>"}]}'
-```
-
-### 8. 启动工作流
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/workflow/<workflow_uuid>/run" -H "$AUTH"
-```
-
-### 9. 运行设备单动作
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/mcp/run/action" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"lab_uuid":"<lab_uuid>","device_id":"virtual_workbench","action":"<action_name>","action_type":"<type>","param":{...}}'
-```
-
-`param` 直接放 goal 里的属性，**不要**再包一层 `{"goal": {...}}`。
-
-> **WARNING: `action_type` 必须正确，传错会导致任务永远卡住无法完成。** 从下表或 `actions/<name>.json` 的 `type` 字段获取。
-
-#### action_type 速查表
-
-| action | action_type |
-|--------|-------------|
-| `auto-prepare_materials` | `UniLabJsonCommand` |
-| `auto-move_to_heating_station` | `UniLabJsonCommand` |
-| `auto-start_heating` | `UniLabJsonCommand` |
-| `auto-move_to_output` | `UniLabJsonCommand` |
-| `transfer` | `UniLabJsonCommandAsync` |
-| `manual_confirm` | `UniLabJsonCommand` |
-
-### 10. 查询任务状态
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/mcp/task/<task_uuid>" -H "$AUTH"
-```
-
-### 11. 运行工作流单节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/lab/mcp/run/workflow/action" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"node_uuid":"<node_uuid>"}'
-```
-
-### 12. 获取资源树（物料信息）
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/download/$lab_uuid" -H "$AUTH"
-```
-
-注意 `lab_uuid` 在路径中。返回 `data.nodes[]` 含所有节点（设备 + 物料），每个节点含 `name`、`uuid`、`type`、`parent`。
-
-### 13. 获取工作流模板详情
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/workflow/template/detail/$workflow_uuid" -H "$AUTH"
-```
-
-> 必须使用 `/lab/workflow/template/detail/{uuid}`，其他路径会返回 404。
-
-### 14. 按名称查询物料模板
-
-```bash
-curl -s -X GET "$BASE/api/v1/lab/material/template/by-name?lab_uuid=$lab_uuid&name=<template_name>" -H "$AUTH"
-```
-
-返回 `data.uuid` 为 `res_template_uuid`，用于 API #15。
-
-### 15. 创建物料节点
-
-```bash
-curl -s -X POST "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"res_template_uuid":"<uuid>","name":"<名称>","display_name":"<显示名>","parent_uuid":"<父节点uuid>","data":{...}}'
-```
-
-### 16. 更新物料节点
-
-```bash
-curl -s -X PUT "$BASE/api/v1/edge/material/node" \
-  -H "$AUTH" -H "Content-Type: application/json" \
-  -d '{"uuid":"<节点uuid>","display_name":"<新名称>","data":{...}}'
-```
-
----
-
-## Placeholder Slot 填写规则
-
-| `placeholder_keys` 值 | Slot 类型    | 填写格式                                              | 选取范围               |
-| --------------------- | ------------ | ----------------------------------------------------- | ---------------------- |
-| `unilabos_resources`  | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` | 仅物料节点（非设备）   |
-| `unilabos_devices`    | DeviceSlot   | `"/parent/device_name"`                               | 仅设备节点（type=device） |
-| `unilabos_nodes`      | NodeSlot     | `"/parent/node_name"`                                 | 所有节点（设备 + 物料）   |
-| `unilabos_class`      | ClassSlot    | `"class_name"`                                        | 注册表中已注册的资源类    |
-
-### virtual_workbench 设备的 Slot 字段表
-
-| Action            | 字段             | Slot 类型    | 说明                 |
-| ----------------- | ---------------- | ------------ | -------------------- |
-| `transfer`        | `resource`       | ResourceSlot | 待转移物料数组       |
-| `transfer`        | `target_device`  | DeviceSlot   | 目标设备路径         |
-| `transfer`        | `mount_resource` | ResourceSlot | 目标孔位数组         |
-| `manual_confirm`  | `resource`       | ResourceSlot | 确认用物料数组       |
-| `manual_confirm`  | `target_device`  | DeviceSlot   | 确认用目标设备       |
-| `manual_confirm`  | `mount_resource` | ResourceSlot | 确认用目标孔位数组   |
-
-> `prepare_materials`、`move_to_heating_station`、`start_heating`、`move_to_output` 这 4 个动作**无 Slot 字段**，参数为纯数值/整数。
-
----
-
-## 渐进加载策略
-
-1. **SKILL.md**（本文件）— API 端点 + session state 管理 + 设备工作流概览
-2. **[action-index.md](action-index.md)** — 按分类浏览 6 个动作的描述和核心参数
-3. **[actions/\<name\>.json](actions/)** — 仅在需要构建具体请求时，加载对应 action 的完整 JSON Schema
-
----
-
-## 完整工作流 Checklist
-
-```
-Task Progress:
-- [ ] Step 1: GET /edge/lab/info 获取 lab_uuid
-- [ ] Step 2: 获取资源树 (GET #12) → 记住可用物料
-- [ ] Step 3: 读 action-index.md 确定要用的 action 名
-- [ ] Step 4: 创建工作流 (POST #2) → 记住 workflow_uuid，告知用户链接
-- [ ] Step 5: 创建节点 (POST #3, resource_template_name=virtual_workbench) → 记住 node_uuid + data.param
-- [ ] Step 6: 根据 _unilabos_placeholder_info 和资源树，填写 data.param 中的 Slot 字段
-- [ ] Step 7: 更新节点参数 (PATCH #5)
-- [ ] Step 8: 查询节点 handles (POST #6) → 获取各节点的 handle_uuid
-- [ ] Step 9: 批量创建边 (POST #7) → 用 handle_uuid 连接节点
-- [ ] Step 10: 启动工作流 (POST #8) 或运行单节点 (POST #11)
-- [ ] Step 11: 查询任务状态 (GET #10) 确认完成
-```
-
-### 典型 5 物料并发加热工作流示例
-
-```
-prepare_materials (count=5)
-  ├─ channel_1 → move_to_heating_station (material_number=1) → start_heating → move_to_output
-  ├─ channel_2 → move_to_heating_station (material_number=2) → start_heating → move_to_output
-  ├─ channel_3 → move_to_heating_station (material_number=3) → start_heating → move_to_output
-  ├─ channel_4 → move_to_heating_station (material_number=4) → start_heating → move_to_output
-  └─ channel_5 → move_to_heating_station (material_number=5) → start_heating → move_to_output
-```
-
-创建节点时，`prepare_materials` 的 5 个 output handle（`channel_1` ~ `channel_5`）分别连接到 5 个 `move_to_heating_station` 节点的 `material_input` handle。每个 `move_to_heating_station` 的 `heating_station_output` 和 `material_number_output` 连接到对应 `start_heating` 的 `station_id_input` 和 `material_number_input`。

.cursor/skills/virtual-workbench/action-index.md

@@ -1,76 +0,0 @@
-# Action Index — virtual_workbench
-
-6 个动作，按功能分类。每个动作的完整 JSON Schema 在 `actions/<name>.json`。
-
----
-
-## 物料准备
-
-### `auto-prepare_materials`
-
-批量准备物料（虚拟起始节点），生成 A1-A5 物料编号，输出 5 个 handle 供后续节点使用
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/prepare_materials.json`](actions/prepare_materials.json)
-- **可选参数**: `count`（物料数量，默认 5）
-
----
-
-## 机械臂 & 加热台操作
-
-### `auto-move_to_heating_station`
-
-将物料从 An 位置移动到空闲加热台（竞争机械臂，自动查找空闲加热台）
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/move_to_heating_station.json`](actions/move_to_heating_station.json)
-- **核心参数**: `material_number`（物料编号，integer）
-
-### `auto-start_heating`
-
-启动指定加热台的加热程序（可并行，3 个加热台同时工作）
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/start_heating.json`](actions/start_heating.json)
-- **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
-
-### `auto-move_to_output`
-
-将加热完成的物料从加热台移动到输出位置 Cn
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/move_to_output.json`](actions/move_to_output.json)
-- **核心参数**: `station_id`（加热台 ID），`material_number`（物料编号）
-
----
-
-## 物料转移
-
-### `transfer`
-
-异步转移物料到目标设备（通过 ROS 资源转移）
-
-- **action_type**: `UniLabJsonCommandAsync`
-- **Schema**: [`actions/transfer.json`](actions/transfer.json)
-- **核心参数**: `resource`, `target_device`, `mount_resource`
-- **占位符字段**:
-  - `resource` — **ResourceSlot**，待转移的物料数组 `[{id, name, uuid}, ...]`
-  - `target_device` — **DeviceSlot**，目标设备路径字符串
-  - `mount_resource` — **ResourceSlot**，目标孔位数组 `[{id, name, uuid}, ...]`
-
----
-
-## 人工确认
-
-### `manual_confirm`
-
-创建人工确认节点，等待用户手动确认后继续（含物料转移上下文）
-
-- **action_type**: `UniLabJsonCommand`
-- **Schema**: [`actions/manual_confirm.json`](actions/manual_confirm.json)
-- **核心参数**: `resource`, `target_device`, `mount_resource`, `timeout_seconds`, `assignee_user_ids`
-- **占位符字段**:
-  - `resource` — **ResourceSlot**，物料数组
-  - `target_device` — **DeviceSlot**，目标设备路径
-  - `mount_resource` — **ResourceSlot**，目标孔位数组
-  - `assignee_user_ids` — `unilabos_manual_confirm` 类型

.cursor/skills/virtual-workbench/actions/manual_confirm.json

@@ -1,270 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "resource": "resource",
-    "target_device": "target_device",
-    "mount_resource": "mount_resource",
-    "timeout_seconds": "timeout_seconds",
-    "assignee_user_ids": "assignee_user_ids"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "resource": {
-        "items": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sample_id": {
-              "type": "string"
-            },
-            "children": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "parent": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string"
-            },
-            "category": {
-              "type": "string"
-            },
-            "pose": {
-              "type": "object",
-              "properties": {
-                "position": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z"
-                  ],
-                  "title": "position",
-                  "additionalProperties": false
-                },
-                "orientation": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "w": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z",
-                    "w"
-                  ],
-                  "title": "orientation",
-                  "additionalProperties": false
-                }
-              },
-              "required": [
-                "position",
-                "orientation"
-              ],
-              "title": "pose",
-              "additionalProperties": false
-            },
-            "config": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
-            }
-          },
-          "title": "resource"
-        },
-        "type": "array"
-      },
-      "target_device": {
-        "type": "string",
-        "description": "device reference"
-      },
-      "mount_resource": {
-        "items": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sample_id": {
-              "type": "string"
-            },
-            "children": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "parent": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string"
-            },
-            "category": {
-              "type": "string"
-            },
-            "pose": {
-              "type": "object",
-              "properties": {
-                "position": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z"
-                  ],
-                  "title": "position",
-                  "additionalProperties": false
-                },
-                "orientation": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "w": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z",
-                    "w"
-                  ],
-                  "title": "orientation",
-                  "additionalProperties": false
-                }
-              },
-              "required": [
-                "position",
-                "orientation"
-              ],
-              "title": "pose",
-              "additionalProperties": false
-            },
-            "config": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
-            }
-          },
-          "title": "mount_resource"
-        },
-        "type": "array"
-      },
-      "timeout_seconds": {
-        "type": "integer"
-      },
-      "assignee_user_ids": {
-        "type": "array",
-        "items": {
-          "type": "string"
-        }
-      }
-    },
-    "required": [
-      "resource",
-      "target_device",
-      "mount_resource",
-      "timeout_seconds",
-      "assignee_user_ids"
-    ],
-    "_unilabos_placeholder_info": {
-      "resource": "unilabos_resources",
-      "target_device": "unilabos_devices",
-      "mount_resource": "unilabos_resources",
-      "assignee_user_ids": "unilabos_manual_confirm"
-    }
-  },
-  "goal_default": {},
-  "placeholder_keys": {
-    "resource": "unilabos_resources",
-    "target_device": "unilabos_devices",
-    "mount_resource": "unilabos_resources",
-    "assignee_user_ids": "unilabos_manual_confirm"
-  }
-}

.cursor/skills/virtual-workbench/actions/move_to_heating_station.json

@@ -1,19 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "material_number": "material_number"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "material_number": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "material_number"
-    ]
-  },
-  "goal_default": {},
-  "placeholder_keys": {}
-}

.cursor/skills/virtual-workbench/actions/move_to_output.json

@@ -1,24 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "station_id": "station_id",
-    "material_number": "material_number"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "station_id": {
-        "type": "integer"
-      },
-      "material_number": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "station_id",
-      "material_number"
-    ]
-  },
-  "goal_default": {},
-  "placeholder_keys": {}
-}

.cursor/skills/virtual-workbench/actions/prepare_materials.json

@@ -1,20 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "count": "count"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "count": {
-        "type": "integer",
-        "default": 5
-      }
-    },
-    "required": []
-  },
-  "goal_default": {
-    "count": 5
-  },
-  "placeholder_keys": {}
-}

.cursor/skills/virtual-workbench/actions/start_heating.json

@@ -1,24 +0,0 @@
-{
-  "type": "UniLabJsonCommand",
-  "goal": {
-    "station_id": "station_id",
-    "material_number": "material_number"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "station_id": {
-        "type": "integer"
-      },
-      "material_number": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "station_id",
-      "material_number"
-    ]
-  },
-  "goal_default": {},
-  "placeholder_keys": {}
-}

.cursor/skills/virtual-workbench/actions/transfer.json

@@ -1,255 +0,0 @@
-{
-  "type": "UniLabJsonCommandAsync",
-  "goal": {
-    "resource": "resource",
-    "target_device": "target_device",
-    "mount_resource": "mount_resource"
-  },
-  "schema": {
-    "type": "object",
-    "properties": {
-      "resource": {
-        "items": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sample_id": {
-              "type": "string"
-            },
-            "children": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "parent": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string"
-            },
-            "category": {
-              "type": "string"
-            },
-            "pose": {
-              "type": "object",
-              "properties": {
-                "position": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z"
-                  ],
-                  "title": "position",
-                  "additionalProperties": false
-                },
-                "orientation": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "w": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z",
-                    "w"
-                  ],
-                  "title": "orientation",
-                  "additionalProperties": false
-                }
-              },
-              "required": [
-                "position",
-                "orientation"
-              ],
-              "title": "pose",
-              "additionalProperties": false
-            },
-            "config": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
-            }
-          },
-          "title": "resource"
-        },
-        "type": "array"
-      },
-      "target_device": {
-        "type": "string",
-        "description": "device reference"
-      },
-      "mount_resource": {
-        "items": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sample_id": {
-              "type": "string"
-            },
-            "children": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "parent": {
-              "type": "string"
-            },
-            "type": {
-              "type": "string"
-            },
-            "category": {
-              "type": "string"
-            },
-            "pose": {
-              "type": "object",
-              "properties": {
-                "position": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z"
-                  ],
-                  "title": "position",
-                  "additionalProperties": false
-                },
-                "orientation": {
-                  "type": "object",
-                  "properties": {
-                    "x": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "y": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "z": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    },
-                    "w": {
-                      "type": "number",
-                      "minimum": -1.7976931348623157e+308,
-                      "maximum": 1.7976931348623157e+308
-                    }
-                  },
-                  "required": [
-                    "x",
-                    "y",
-                    "z",
-                    "w"
-                  ],
-                  "title": "orientation",
-                  "additionalProperties": false
-                }
-              },
-              "required": [
-                "position",
-                "orientation"
-              ],
-              "title": "pose",
-              "additionalProperties": false
-            },
-            "config": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
-            }
-          },
-          "title": "mount_resource"
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "resource",
-      "target_device",
-      "mount_resource"
-    ],
-    "_unilabos_placeholder_info": {
-      "resource": "unilabos_resources",
-      "target_device": "unilabos_devices",
-      "mount_resource": "unilabos_resources"
-    }
-  },
-  "goal_default": {},
-  "placeholder_keys": {
-    "resource": "unilabos_resources",
-    "target_device": "unilabos_devices",
-    "mount_resource": "unilabos_resources"
-  }
-}

.cursorignore

@@ -1,188 +1,26 @@
-# ============================================================
-# Uni-Lab-OS Cursor Ignore 配置，控制 Cursor AI 的文件索引范围
-# ============================================================
-
-# ==================== 敏感配置文件 ====================
-# 本地配置（可能包含密钥）
-**/local_config.py
-test_config.py
-local_test*.py
-
-# 环境变量和密钥
-.env
-.env.*
-**/.certs/
-*.pem
-*.key
-credentials.json
-secrets.yaml
-
-# ==================== 二进制和 3D 模型文件 ====================
-# 3D 模型文件（无需索引）
-*.stl
-*.dae
-*.glb
-*.gltf
-*.obj
-*.fbx
-*.blend
-
-# URDF/Xacro 机器人描述文件（大型XML）
-*.xacro
-
-# 图片文件
-*.png
-*.jpg
-*.jpeg
-*.gif
-*.webp
-*.ico
-*.svg
-*.bmp
-
-# 压缩包
-*.zip
-*.tar
-*.tar.gz
-*.tgz
-*.bz2
-*.rar
-*.7z
-
-# ==================== Python 生成文件 ====================
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-*.pyd
-*.egg
-*.egg-info/
-.eggs/
-dist/
-build/
-*.manifest
-*.spec
-
-# ==================== IDE 和编辑器 ====================
-.idea/
-.vscode/
-*.swp
-*.swo
-*~
-.#*
-
-# ==================== 测试和覆盖率 ====================
-.pytest_cache/
-.coverage
-.coverage.*
-htmlcov/
-.tox/
-.nox/
-coverage.xml
-*.cover
-
-# ==================== 虚拟环境 ====================
-.venv/
-venv/
-env/
-ENV/
-
-# ==================== ROS 2 生成文件 ====================
-# ROS 构建目录
-build/
-install/
-log/
-logs/
-devel/
-
-# ROS 消息生成
-msg_gen/
-srv_gen/
-msg/*Action.msg
-msg/*ActionFeedback.msg
-msg/*ActionGoal.msg
-msg/*ActionResult.msg
-msg/*Feedback.msg
-msg/*Goal.msg
-msg/*Result.msg
-msg/_*.py
-srv/_*.py
-build_isolated/
-devel_isolated/
-
-# ROS 动态配置
-*.cfgc
-/cfg/cpp/
-/cfg/*.py
-
-# ==================== 项目特定目录 ====================
-# 工作数据目录
-unilabos_data/
-
-# 临时和输出目录
-temp/
-output/
-cursor_docs/
-configs/
-
-# 文档构建
-docs/_build/
-/site
-
-# ==================== 大型数据文件 ====================
-# 点云数据
-*.pcd
-
-# GraphML 图形文件
-*.graphml
-
-# 日志文件
-*.log
-
-# 数据库
-*.sqlite3
-*.db
-
-# Jupyter 检查点
-.ipynb_checkpoints/
-
-# ==================== 设备网格资源 ====================
-# 3D 网格文件目录（包含大量 STL/DAE 文件）
-unilabos/device_mesh/devices/**/*.stl
-unilabos/device_mesh/devices/**/*.dae
-unilabos/device_mesh/resources/**/*.stl
-unilabos/device_mesh/resources/**/*.glb
-unilabos/device_mesh/resources/**/*.xacro
-
-# RViz 配置
-*.rviz
-
-# ==================== 系统文件 ====================
-.DS_Store
-Thumbs.db
-desktop.ini
-
-# ==================== 锁文件 ====================
-poetry.lock
-Pipfile.lock
-pdm.lock
-package-lock.json
-yarn.lock
-
-# ==================== 类型检查缓存 ====================
-.mypy_cache/
-.dmypy.json
-.pytype/
-.pyre/
+.conda
+# .github
+.idea
+# .vscode
+output
+pylabrobot_repo
+recipes
+scripts
+service
+temp
+# unilabos/test
+# unilabos/app/web
+unilabos/device_mesh
+unilabos_data
+unilabos_msgs
+unilabos.egg-info
+CONTRIBUTORS
+# LICENSE
+MANIFEST.in
 pyrightconfig.json
-
-# ==================== 其他 ====================
-# Catkin
-CATKIN_IGNORE
-
-# Eclipse/Qt
-.project
-.cproject
-CMakeLists.txt.user
-*.user
-qtcreator-*
+# README.md
+# README_zh.md
+setup.py
+setup.cfg
+.gitattrubutes
+**/__pycache__

.github/copilot-instructions.md

@@ -1,11 +0,0 @@
-## 设备接入
-
-当被要求添加设备驱动时，参考 `docs/ai_guides/add_device.md`。
-该指南包含完整的模板和已有设备接口参考。
-
-## 关键规则
-
-- 动作方法的参数名是接口契约，不可重命名
-- `status` 字符串必须与同类已有设备一致
-- `self.data` 必须在 `__init__` 中预填充所有属性字段
-- 异步方法中使用 `await self._ros_node.sleep()`，禁止 `time.sleep()`

.github/dependabot.yml

@@ -1,19 +0,0 @@
-version: 2
-updates:
-# GitHub Actions
-- package-ecosystem: "github-actions"
-  directory: "/"
-  target-branch: "dev"
-  schedule:
-    interval: "weekly"
-    day: "monday"
-    time: "06:00"
-  open-pull-requests-limit: 5
-  reviewers:
-  - "msgcenterpy-team"
-  labels:
-  - "dependencies"
-  - "github-actions"
-  commit-message:
-    prefix: "ci"
-    include: "scope"

.gitignore

@@ -252,3 +252,5 @@ ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
 test_config.py
 
 
+/.claude
+/.cursor

CLAUDE.md

@@ -1,4 +1,124 @@
+# CLAUDE.md
 
-Please follow the rules defined in:
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
-@AGENTS.md
+## Build & Development
+
+```bash
+# Install (requires mamba env with python 3.11)
+mamba create -n unilab python=3.11.14
+mamba activate unilab
+mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
+pip install -e .
+uv pip install -r unilabos/utils/requirements.txt
+
+# Run with a device graph
+unilab --graph <graph.json> --config <config.py> --backend ros
+unilab --graph <graph.json> --config <config.py> --backend simple  # no ROS2 needed
+
+# Common CLI flags
+unilab --app_bridges websocket fastapi    # communication bridges
+unilab --test_mode                        # simulate hardware, no real execution
+unilab --check_mode                       # CI validation of registry imports (AST-based)
+unilab --skip_env_check                   # skip auto-install of dependencies
+unilab --visual rviz|web|disable          # visualization mode
+unilab --is_slave                         # run as slave node
+unilab --restart_mode                     # auto-restart on config changes (supervisor/child process)
+unilab --external_devices_only            # only load external device packages
+unilab --extra_resource                   # load extra lab_ prefixed labware resources
+
+# Workflow upload subcommand
+unilab workflow_upload -f <workflow.json> -n <name> --tags tag1 tag2
+
+# Labware Manager (standalone web UI for PRCXI labware CRUD, port 8010)
+python -m unilabos.labware_manager
+
+# Tests
+pytest tests/                              # all tests
+pytest tests/resources/test_resourcetreeset.py  # single test file
+pytest tests/resources/test_resourcetreeset.py::TestClassName::test_method  # single test
+
+# CI check (matches .github/workflows/ci-check.yml)
+python -m unilabos --check_mode --skip_env_check
+
+# If registry YAML/Python files changed, regenerate before committing:
+python -m unilabos --complete_registry
+
+# Documentation build
+cd docs && python -m sphinx -b html . _build/html -v
+```
+
+## Architecture
+
+### Startup Flow
+
+`unilab` CLI (entry point in `setup.py`) → `unilabos/app/main.py:main()` → loads config → builds registry → reads device graph (JSON/GraphML) → starts backend thread (ROS2/simple) → starts FastAPI web server + WebSocket client.
+
+### Core Layers
+
+**Registry** (`unilabos/registry/`): Singleton `Registry` class discovers and catalogs all device types, resource types, and communication devices. Two registration mechanisms:
+1. **YAML definitions** in `registry/devices/*.yaml` and `registry/resources/` (backward-compatible)
+2. **Python decorators** (`@device`, `@action`, `@resource` in `registry/decorators.py`) — preferred for new code
+
+AST scanning (`ast_registry_scanner.py`) discovers decorated classes without importing them, so `--check_mode` works without hardware dependencies. Class paths resolved to Python classes at runtime via `utils/import_manager.py`.
+
+Decorator usage pattern:
+```python
+from unilabos.registry.decorators import device, action, resource
+from unilabos.registry.decorators import InputHandle, OutputHandle, HardwareInterface
+
+@device(id="my_device.v1", category=["category_name"], handles=[...])
+class MyDevice:
+    @action(action_type=SomeActionType)
+    def do_something(self): ...
+```
+
+**Resource Tracking** (`unilabos/resources/resource_tracker.py`): Pydantic-based `ResourceDict` → `ResourceDictInstance` → `ResourceTreeSet` hierarchy. `ResourceTreeSet` is the canonical in-memory representation of all devices and resources. Graph I/O in `resources/graphio.py` reads JSON/GraphML device topology files into `nx.Graph` + `ResourceTreeSet`.
+
+**Device Drivers** (`unilabos/devices/`): 30+ hardware drivers organized by category (liquid_handling, hplc, balance, arm, etc.). Each driver class gets wrapped by `ros/device_node_wrapper.py:ros2_device_node()` into a `ROS2DeviceNode` (defined in `ros/nodes/base_device_node.py`) with publishers, subscribers, and action servers.
+
+**ROS2 Layer** (`unilabos/ros/`): Preset node types in `ros/nodes/presets/` — `host_node` (main orchestrator, ~90KB), `controller_node`, `workstation`, `serial_node`, `camera`, `resource_mesh_manager`. Custom messages in `unilabos_msgs/` (80+ action types, pre-built via conda `ros-humble-unilabos-msgs`).
+
+**Protocol Compilation** (`unilabos/compile/`): 20+ protocol compilers (add, centrifuge, dissolve, filter, heatchill, stir, pump, etc.) registered in `__init__.py:action_protocol_generators` dict. Utility parsers in `compile/utils/` (vessel, unit, logger).
+
+**Workflow** (`unilabos/workflow/`): Converts workflow definitions from multiple formats — JSON (`convert_from_json.py`, `common.py`), Python scripts (`from_python_script.py`), XDL (`from_xdl.py`) — into executable `WorkflowGraph`. Legacy converters in `workflow/legacy/`.
+
+**Communication** (`unilabos/device_comms/`): Hardware adapters — OPC-UA, Modbus PLC, RPC, universal driver. `app/communication.py` provides factory pattern for WebSocket connections.
+
+**Web/API** (`unilabos/app/web/`): FastAPI server with REST API (`api.py`), Jinja2 templates (`pages.py`), HTTP client (`client.py`). Default port 8002.
+
+**Labware Manager** (`unilabos/labware_manager/`): Standalone FastAPI web app (port 8010) for PRCXI labware CRUD. Pydantic models in `models.py`, JSON database in `labware_db.json`. Supports importing from existing Python/YAML (`importer.py`), code generation (`codegen.py`), and YAML generation (`yaml_gen.py`). Web UI with SVG visualization (`static/labware_viz.js`), dynamic form handling (`static/form_handler.js`), and Jinja2 templates.
+
+### Configuration System
+
+- **Config classes** in `unilabos/config/config.py`: `BasicConfig`, `WSConfig`, `HTTPConfig`, `ROSConfig` — class-level attributes, loaded from Python `.py` config files (see `config/example_config.py`)
+- Environment variable overrides with prefix `UNILABOS_` (e.g., `UNILABOS_BASICCONFIG_PORT=9000`)
+- Device topology defined in graph files (JSON node-link format or GraphML)
+
+### Key Data Flow
+
+1. Graph file → `graphio.read_node_link_json()` → `(nx.Graph, ResourceTreeSet, resource_links)`
+2. `ResourceTreeSet` + `Registry` → `initialize_device.initialize_device_from_dict()` → `ROS2DeviceNode` instances
+3. Device nodes communicate via ROS2 topics/actions or direct Python calls (simple backend)
+4. Cloud sync via WebSocket (`app/ws_client.py`) and HTTP (`app/web/client.py`)
+
+### Test Data
+
+Example device graphs and experiment configs are in `unilabos/test/experiments/` (not `tests/`). Registry test fixtures in `unilabos/test/registry/`.
+
+## Code Conventions
+
+- Code comments and log messages in **simplified Chinese**
+- Python 3.11+, type hints expected
+- Pydantic models for data validation (`resource_tracker.py`)
+- Singleton pattern via `@singleton` decorator (`utils/decorator.py`)
+- Dynamic class loading via `utils/import_manager.py` — device classes resolved at runtime from registry YAML paths
+- CLI argument dashes auto-converted to underscores for consistency
+- No linter/formatter configuration enforced (no ruff, black, flake8, mypy configs)
+- Documentation built with Sphinx (Chinese language, `sphinx_rtd_theme`, `myst_parser`)
+- CI runs on Windows (`windows-latest`); if registry files change, run `python -m unilabos --complete_registry` locally before committing
+
+## Licensing
+
+- Framework code: GPL-3.0
+- Device drivers (`unilabos/devices/`): DP Technology Proprietary License — do not redistribute

docs/advanced_usage/configuration.md

@@ -12,7 +12,7 @@ Uni-Lab 使用 Python 格式的配置文件（`.py`），默认为 `unilabos_dat
 
 **获取方式：**
 
-进入 [Uni-Lab 实验室](https://leap-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：
+进入 [Uni-Lab 实验室](https://uni-lab.bohrium.com)，点击左下角的头像，在实验室详情中获取所在实验室的 ak 和 sk：
 
 ![copy_aksk.gif](image/copy_aksk.gif)
 
@@ -69,7 +69,7 @@ class WSConfig:
 
 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://leap-lab.bohrium.com/api/v1"  # 远程服务器地址
+    remote_addr = "https://uni-lab.bohrium.com/api/v1"  # 远程服务器地址
 
 # ROS配置
 class ROSConfig:
@@ -209,8 +209,8 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap
 
 `--addr` 参数支持以下预设值，会自动转换为对应的完整 URL：
 
-- `test` → `https://leap-lab.test.bohrium.com/api/v1`
-- `uat` → `https://leap-lab.uat.bohrium.com/api/v1`
+- `test` → `https://uni-lab.test.bohrium.com/api/v1`
+- `uat` → `https://uni-lab.uat.bohrium.com/api/v1`
 - `local` → `http://127.0.0.1:48197/api/v1`
 - 其他值 → 直接使用作为完整 URL
 
@@ -248,7 +248,7 @@ unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis -g grap
 
 `ak` 和 `sk` 是必需的认证参数：
 
-1. **获取方式**：在 [Uni-Lab 官网](https://leap-lab.bohrium.com) 注册实验室后获得
+1. **获取方式**：在 [Uni-Lab 官网](https://uni-lab.bohrium.com) 注册实验室后获得
 2. **配置方式**：
    - **命令行参数**：`--ak "your_key" --sk "your_secret"`（最高优先级，推荐）
    - **环境变量**：`UNILABOS_BASICCONFIG_AK` 和 `UNILABOS_BASICCONFIG_SK`
@@ -275,15 +275,15 @@ WebSocket 是 Uni-Lab 的主要通信方式：
 
 HTTP 客户端配置用于与云端服务通信：
 
-| 参数          | 类型 | 默认值                                  | 说明         |
-| ------------- | ---- | --------------------------------------- | ------------ |
-| `remote_addr` | str  | `"https://leap-lab.bohrium.com/api/v1"` | 远程服务地址 |
+| 参数          | 类型 | 默认值                                 | 说明         |
+| ------------- | ---- | -------------------------------------- | ------------ |
+| `remote_addr` | str  | `"https://uni-lab.bohrium.com/api/v1"` | 远程服务地址 |
 
 **预设环境地址**：
 
-- 生产环境：`https://leap-lab.bohrium.com/api/v1`（默认）
-- 测试环境：`https://leap-lab.test.bohrium.com/api/v1`
-- UAT 环境：`https://leap-lab.uat.bohrium.com/api/v1`
+- 生产环境：`https://uni-lab.bohrium.com/api/v1`（默认）
+- 测试环境：`https://uni-lab.test.bohrium.com/api/v1`
+- UAT 环境：`https://uni-lab.uat.bohrium.com/api/v1`
 - 本地环境：`http://127.0.0.1:48197/api/v1`
 
 ### 4. ROSConfig - ROS 配置
@@ -401,7 +401,7 @@ export UNILABOS_WSCONFIG_RECONNECT_INTERVAL="10"
 export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS="500"
 
 # 设置HTTP配置
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://leap-lab.test.bohrium.com/api/v1"
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://uni-lab.test.bohrium.com/api/v1"
 ```
 
 ## 配置文件使用方法
@@ -484,13 +484,13 @@ export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS=100
 
 ```python
 class HTTPConfig:
-    remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
+    remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
 ```
 
 **环境变量方式：**
 
 ```bash
-export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://leap-lab.test.bohrium.com/api/v1
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR=https://uni-lab.test.bohrium.com/api/v1
 ```
 
 **命令行方式（推荐）：**

docs/ai_guides/agent_prompt_template.md

@@ -1,344 +0,0 @@
-# Uni-Lab-OS 设备接入 Agent — 提示词模板
-
-> 本文件提供一套可直接复制使用的 Agent 系统提示词，以及各平台的配置说明。
-> 提示词模板与 `add_device.md`（领域知识）配合使用，前者控制 Agent 行为，后者提供完整的技术细节。
-
----
-
-## 系统提示词模板
-
-以下内容可直接作为系统提示词 / Instructions / Custom Instructions 使用。`{{...}}` 标记的变量根据平台替换。
-
----
-
-### 开始复制 ↓
-
-```
-你是 Uni-Lab-OS 设备接入专家。你的任务是帮助用户将新的实验室硬件设备接入 Uni-Lab-OS 系统。
-
-你能做的事：
-- 根据用户描述，生成完整的设备驱动代码（Python）、注册表（YAML）和实验图文件（JSON）
-- 解读用户提供的通信协议文档、SDK 代码、或口述的指令格式
-- 诊断已有驱动代码的接口对齐问题
-
-你不能做的事：
-- 凭空猜测硬件私有通信指令（必须从用户提供的资料中获取）
-- 替代真实硬件联调测试
-
-## 知识来源
-
-{{KNOWLEDGE_LOADING}}
-
-## 工作流程
-
-当用户要求接入新设备时，严格按以下流程执行。每个暂停点必须等待用户确认后再继续。
-
-### 阶段 1：设备画像（交互）
-
-向用户收集以下三个信息，可以一次性提问：
-
-1. **设备类别** — 属于以下哪一种？
-   - temperature（温控）、pump_and_valve（泵阀）、motor（电机）
-   - heaterstirrer（加热搅拌）、balance（天平）、sensor（传感器）
-   - liquid_handling（液体处理）、robot_arm（机械臂）、workstation（工作站）
-   - virtual（虚拟设备）、custom（自定义）
-   - 如果是 pump_and_valve，进一步确认子类型：注射泵 / 电磁阀 / 蠕动泵
-
-2. **设备英文名称** — 用于文件名和类名（如 my_heater、runze_sy03b）
-
-3. **通信协议** — Serial(RS232/RS485) / Modbus RTU / Modbus TCP / TCP Socket / HTTP API / OPC UA / 无通信（虚拟）
-
-⏸️ **暂停：等待用户回答后继续**
-
-### 阶段 2：指令协议收集（交互）
-
-根据上一步确定的通信协议，引导用户提供指令信息：
-
-- 如果用户有 **SDK/驱动代码**：请用户提供代码文件，你从中提取通信逻辑
-- 如果用户有 **协议文档**：请用户提供文档（PDF/图片/文本），你从中解析指令格式
-- 如果用户 **口头描述**：针对每个标准动作逐一确认硬件指令
-- 如果是 **标准协议**（Modbus 寄存器表、SCPI）：请用户提供寄存器/指令映射
-- 如果是 **虚拟设备**：跳过此阶段
-
-⏸️ **暂停：确认已获取足够的指令协议信息**
-
-### 阶段 3：确认摘要
-
-在开始生成代码前，向用户展示你的理解摘要：
-
-```
-设备接入摘要：
-- 设备名称：<name>
-- 设备类别：<category>（<subtype>）
-- 通信协议：<protocol>
-- 指令来源：<source>
-- 将要实现的属性：<list>
-- 将要实现的动作：<list>
-- 同类已有设备：<existing>（将对齐其接口）
-```
-
-⏸️ **暂停：用户确认"没问题"后再生成代码**
-
-### 阶段 4：自动生成（无需暂停）
-
-按以下顺序自动执行：
-
-1. **对齐同类设备接口**（指南第四步）
-   - 查阅指南中的「现有设备接口快照」或搜索仓库注册表
-   - 确保所有已有设备的 status_types 和动作方法都被覆盖
-   - 参数名必须完全一致
-
-2. **生成驱动代码** — `unilabos/devices/<category>/<name>.py`
-
-3. **生成注册表** — `unilabos/registry/devices/<name>.yaml`（最小配置）
-
-4. **生成图文件** — `unilabos/test/experiments/graph_example_<name>.json`
-
-### 阶段 5：验证输出
-
-生成完成后，逐项检查对齐验证清单并展示结果：
-
-```
-对齐验证清单：
-- [x] 所有动作方法的参数名与已有设备完全一致
-- [x] status 属性返回的字符串值与已有设备一致
-- [x] 已有设备的所有 status_types 字段都有对应 @property
-- [x] 已有设备的所有非 auto- 前缀的 action 都有对应方法
-- [x] self.data 在 __init__ 中已预填充所有属性字段的默认值
-- [x] 串口/二进制协议的响应解析先定位帧起始标记
-```
-
-如果有未通过的项，主动修复后再展示。
-
-## 硬约束（违反任何一条都会导致设备接入失败）
-
-1. **禁止重命名参数** — 动作方法的参数名（如 volume、position、max_velocity）是接口契约，框架通过参数名分派调用。绝不能加后缀（如 volume_ml）、改名（如 speed_ml_s）。单位写在 docstring 中。
-
-2. **status 字符串必须一致** — 如果同类已有设备用英文（如 "Idle" / "Busy"），新驱动必须用相同的字符串，不能改为中文（如 "就绪"）。
-
-3. **self.data 必须预填充** — 不能用空字典 {}。框架在 initialize() 之前就可能读取属性值。每个 @property 对应的键都必须在 __init__ 中有初始值。
-
-4. **禁止跳过接口对齐** — 对齐同类设备接口是强制步骤。缺失的属性和动作会导致设备在工作流中不可互换。
-
-5. **串口解析先找帧头** — RS-485 总线上响应前常有回声/噪声字节。必须先定位帧起始标记（如 /、0xFE），禁止用硬编码索引直接解析。
-
-6. **异步等待用 _ros_node.sleep** — 在 async 方法中使用 await self._ros_node.sleep()，禁止 time.sleep()（阻塞事件循环）和 asyncio.sleep()。
-
-7. **物理单位对外暴露** — 对外参数使用用户友好的物理单位（mL、°C、RPM），驱动内部负责转换到硬件原始值（步数、Hz、寄存器值）。
-
-## 代码骨架参考
-
-所有设备驱动遵循以下结构：
-
-```python
-import logging
-import time as time_module
-from typing import Dict, Any
-
-try:
-    from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-except ImportError:
-    BaseROS2DeviceNode = None
-
-class MyDevice:
-    _ros_node: "BaseROS2DeviceNode"
-
-    def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
-        if device_id is None and 'id' in kwargs:
-            device_id = kwargs.pop('id')
-        if config is None and 'config' in kwargs:
-            config = kwargs.pop('config')
-        self.device_id = device_id or "unknown_device"
-        self.config = config or {}
-        self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
-        self.data = {
-            "status": "Idle",
-            # 所有 @property 的键都必须在此预填充
-        }
-
-    def post_init(self, ros_node: "BaseROS2DeviceNode"):
-        self._ros_node = ros_node
-
-    async def initialize(self) -> bool:
-        self.data["status"] = "Idle"
-        return True
-
-    async def cleanup(self) -> bool:
-        self.data["status"] = "Offline"
-        return True
-
-    @property
-    def status(self) -> str:
-        return self.data.get("status", "Idle")
-```
-
-## 注册表最小配置
-
-```yaml
-my_device:
-  class:
-    module: unilabos.devices.<category>.<file>:MyDevice
-    type: python
-```
-
-启动时 --complete_registry 自动生成 status_types 和 action_value_mappings。
-
-## 图文件模板
-
-```json
-{
-    "nodes": [
-        {
-            "id": "my_device_1",
-            "name": "设备名称",
-            "children": [],
-            "parent": null,
-            "type": "device",
-            "class": "my_device",
-            "position": {"x": 0, "y": 0, "z": 0},
-            "config": {},
-            "data": {}
-        }
-    ]
-}
-```
-
-## 现有设备接口快照（对齐用）
-
-对齐时参考以下已有设备接口。如果能联网，优先从 GitHub 获取最新版本：
-https://github.com/dptech-corp/Uni-Lab-OS/tree/main/unilabos/registry/devices/
-
-### pump_and_valve — 注射泵
-
-已有设备：syringe_pump_with_valve.runze.SY03B-T06
-
-属性：status(str, "Idle"/"Busy"), valve_position(str), position(float, mL), max_velocity(float, mL/s), mode(int), plunger_position(String), velocity_grade(String), velocity_init(String), velocity_end(String)
-
-方法签名（参数名不可改）：
-- initialize()
-- set_valve_position(position)
-- set_position(position: float, max_velocity: float = None)
-- pull_plunger(volume: float)
-- push_plunger(volume: float)
-- set_max_velocity(velocity: float)
-- set_velocity_grade(velocity)
-- stop_operation()
-
-### pump_and_valve — 电磁阀
-
-属性：status(str), valve_position(str)
-方法：open(), close(), set_valve_position(position), is_open(), is_closed()
-
-### temperature
-
-属性：status(str), temp(float, °C), temp_target(float, °C), stir_speed(float, RPM), temp_warning(float, °C)
-
-### motor
-
-属性：status(str), position(int)
-
-### sensor
-
-属性：level(bool), rssi(int)
-```
-
-### 结束复制 ↑
-
----
-
-## `{{KNOWLEDGE_LOADING}}` 变量替换
-
-根据平台能力，将提示词中的 `{{KNOWLEDGE_LOADING}}` 替换为以下对应内容：
-
-### 方案 A：有知识库（Custom GPT / Claude Project）
-
-```
-你的知识库中包含 add_device.md 文件，这是完整的设备接入指南。
-执行工作流时，参考该文件获取物模型模板、通信协议代码片段、指令协议模式和常见错误检查清单。
-本提示词中的「现有设备接口快照」和「硬约束」是从指南中提炼的关键内容，以确保即使知识库检索不完整也能正确工作。
-```
-
-### 方案 B：有联网能力
-
-```
-执行工作流前，从以下 URL 获取完整的设备接入指南：
-https://raw.githubusercontent.com/dptech-corp/Uni-Lab-OS/main/docs/ai_guides/add_device.md
-
-该指南包含物模型模板、通信协议代码片段、指令协议模式和常见错误检查清单。
-如果无法访问 URL，使用本提示词中内联的「现有设备接口快照」和「代码骨架参考」作为兜底。
-```
-
-### 方案 C：无知识库、无联网
-
-```
-完整的设备接入指南需要用户在对话中提供。
-如果用户未主动提供，请在阶段 1 开始前询问：
-"请将 add_device.md 的内容粘贴到对话中，或上传该文件。如果没有该文件，我将使用内置的精简规则工作。"
-
-本提示词已内联了最关键的内容（硬约束 + 代码骨架 + 接口快照），足以生成基本正确的驱动。
-但完整指南包含更多物模型模板和通信协议代码片段，能显著提升生成质量。
-```
-
----
-
-## 各平台配置指南
-
-### OpenAI Custom GPT
-
-1. 进入 https://chat.openai.com/gpts/editor
-2. **Name**：Uni-Lab-OS 设备接入助手
-3. **Description**：帮助用户将实验室硬件设备接入 Uni-Lab-OS 系统，自动生成驱动代码、注册表和图文件。
-4. **Instructions**：粘贴上方系统提示词，`{{KNOWLEDGE_LOADING}}` 替换为方案 A
-5. **Knowledge**：上传 `docs/ai_guides/add_device.md`
-6. **Capabilities**：开启 Code Interpreter（用于代码验证）
-7. **Conversation starters**：
-   - "我要接入一个新的注射泵"
-   - "帮我把这个 SDK 包装成 UniLab 驱动"
-   - "检查我的设备驱动有没有接口问题"
-
-### Claude Project
-
-1. 创建新 Project
-2. **Custom Instructions**：粘贴系统提示词，`{{KNOWLEDGE_LOADING}}` 替换为方案 A
-3. **Project Knowledge**：上传 `docs/ai_guides/add_device.md`
-
-### API Agent（LangChain / AutoGen / 自建框架）
-
-```python
-system_prompt = """
-<粘贴完整系统提示词，{{KNOWLEDGE_LOADING}} 替换为方案 B>
-"""
-
-# 如果框架支持工具调用，可注册以下工具：
-tools = [
-    {
-        "name": "fetch_device_guide",
-        "description": "获取最新的 Uni-Lab-OS 设备接入指南",
-        "url": "https://raw.githubusercontent.com/dptech-corp/Uni-Lab-OS/main/docs/ai_guides/add_device.md"
-    },
-    {
-        "name": "fetch_registry",
-        "description": "获取最新的设备注册表",
-        "url": "https://raw.githubusercontent.com/dptech-corp/Uni-Lab-OS/main/unilabos/registry/devices/{category}.yaml"
-    },
-]
-```
-
-### Cursor Agent Mode
-
-无需使用本模板。Cursor 中使用已有的 `.cursor/skills/add-device/SKILL.md`，它会自动读取 `docs/ai_guides/add_device.md` 并利用 Cursor 的工具能力（Grep 搜索注册表、AskQuestion 收集信息等）。
-
-### 纯网页对话（ChatGPT / Claude 无 Project）
-
-1. 第一条消息粘贴系统提示词（`{{KNOWLEDGE_LOADING}}` 替换为方案 C）
-2. 第二条消息上传或粘贴 `add_device.md`
-3. 第三条消息开始描述设备
-
----
-
-## 维护说明
-
-- **硬约束更新**：如果 `add_device.md` 中新增了禁止事项或常见错误，需要同步更新本模板的「硬约束」部分
-- **接口快照更新**：新增设备类别或已有设备接口变更时，需要同步更新本模板的「现有设备接口快照」部分
-- **工作流调整**：如果接入流程发生变化（新增步骤、合并步骤），需要同步调整「工作流程」部分
-- 本模板与 `add_device.md` 是**互补关系**：模板定义 Agent 行为，指南提供领域知识。两者独立维护

docs/developer_guide/add_old_device.md

@@ -18,15 +18,13 @@ Uni-Lab 开发团队在仓库中提供了 3 个样例：
 
 - 单一机械设备**电夹爪**，通讯协议可见 [增广夹爪通讯协议](https://doc.rmaxis.com/docs/communication/fieldbus/)，驱动代码位于 `unilabos/devices/gripper/rmaxis_v4.py`
 - 单一通信设备**IO 板卡**，驱动代码位于 `unilabos/device_comms/gripper/SRND_16_IO.py`
-- 执行多设备复杂任务逻辑的**PLC**，Uni-Lab 提供了基于地址表的接入方式和点动工作流编写，测试代码位于 `unilabos/device_comms/modbus_plc/test/test_workflow.py`。详细框架说明请参考 {doc}`plc_framework`
+- 执行多设备复杂任务逻辑的**PLC**，Uni-Lab 提供了基于地址表的接入方式和点动工作流编写，测试代码位于 `unilabos/device_comms/modbus_plc/test/test_workflow.py`
 
 ---
 
 ## 其他工业通信协议：CANopen, Ethernet, OPCUA...
 
-Uni-Lab 已实现基于 OPC UA 协议的 PLC 接管框架，用于后处理工站等项目。与 Modbus 框架相比，OPC UA 框架额外提供了自动节点发现、订阅推送、断线重连等特性。详细说明请参考 {doc}`plc_framework`。
-
-其他协议（CANopen、EtherCAT 等）【敬请期待】
+【敬请期待】
 
 ## 没有接口的老设备老软件：使用 PyWinAuto
 

docs/developer_guide/networking_overview.md

@@ -23,7 +23,7 @@ Uni-Lab-OS 支持多种部署模式：
 ```
 ┌──────────────────────────────────────────────┐
 │      Cloud Platform/Self-hosted Platform     │
-│           leap-lab.bohrium.com                │
+│           uni-lab.bohrium.com                │
 │  (Resource Management, Task Scheduling,      │
 │              Monitoring)                     │
 └────────────────────┬─────────────────────────┘
@@ -444,7 +444,7 @@ ros2 daemon stop && ros2 daemon start
 
 ```bash
 # 测试云端连接
-curl https://leap-lab.bohrium.com/api/v1/health
+curl https://uni-lab.bohrium.com/api/v1/health
 
 # 测试WebSocket
 # 启动Uni-Lab后查看日志

docs/developer_guide/plc_framework.md

@@ -1,281 +0,0 @@
-# PLC 设备接管框架
-
-> 本文档面向初次接触 UniLab-OS 的开发者，介绍系统如何通过工业协议"接管"（连接并控制）PLC 设备。
-
-## 什么是"PLC 接管"？
-
-**PLC**（可编程逻辑控制器）是工厂设备的控制核心，驱动机械臂、泵、阀门等硬件。UniLab-OS 通过网络协议直接读写 PLC 内部变量，从而控制设备运行：
-
-```
-UniLab-OS（Python）  ←通信协议→  PLC  ←电信号→  电机/气缸/传感器
-```
-
-UniLab-OS 提供两套接管框架，对应两种工业协议：
-
-| 框架            | 协议             | 应用项目           | 核心文件                                                    |
-| --------------- | ---------------- | ------------------ | ----------------------------------------------------------- |
-| **Modbus 框架** | Modbus TCP / RTU | 扣式电池装配工站   | `unilabos/device_comms/modbus_plc/client.py`                |
-| **OPC UA 框架** | OPC UA           | 后处理工站（怀柔） | `unilabos/devices/workstation/post_process/post_process.py` |
-
-两套框架**设计思想完全一致**，底层通信协议不同。理解一个，另一个基本触类旁通。
-
----
-
-## 核心概念
-
-### 节点（Node）
-
-节点是 PLC 内部一个具体的变量地址，可以理解为 PLC 的一个输入/输出端口。
-
-| 属性 | 说明                                   | 示例                 |
-| ---- | -------------------------------------- | -------------------- |
-| 名称 | 人类可读标识                           | `COIL_SYS_START_CMD` |
-| 地址 | PLC 内存地址                           | `0x0064`             |
-| 类型 | Coil / HoldRegister / InputRegister 等 | `coil`               |
-
-```
-PLC 内存空间
-├── Coil 区:    True / False  ← 控制开关量（启动/停止/复位）
-├── Hold Reg:   120, 35.5 …  ← 存参数值（速度、位置）
-└── Input Reg:  99.8, 42 …   ← 只读传感器数据
-```
-
-### 动作生命周期（Action Lifecycle）
-
-每个设备动作被拆分为 4 个阶段，用 `try/finally` 保证安全性：
-
-```python
-try:
-    init(...)    # 写入参数（速度、位置等）— 可选
-    start(...)   # 发触发信号 + 轮询等待完成
-    stop(...)    # 复位触发信号（成功时执行）
-except:
-    is_err = True
-finally:
-    cleanup(...) # 无论成败都执行，作为安全兜底
-```
-
-| 阶段      | 何时执行                | 典型内容                             |
-| --------- | ----------------------- | ------------------------------------ |
-| `init`    | 成功路径（可选）        | 写运动速度 = 20.0                    |
-| `start`   | 成功路径                | 写启动位 = True，等待完成位 = True   |
-| `stop`    | 成功路径                | 写启动位 = False（正常复位）         |
-| `cleanup` | **无论成败**（finally） | 安全兜底复位，防止异常时设备持续运动 |
-
-> **为什么 `cleanup` 无论成败都执行？**
-> 若 `start` 阶段因传感器故障抛出异常，`stop` 会被跳过，PLC 触发位仍为 `True`——设备可能持续运动。`cleanup` 放在 `finally` 块中，作为最后的安全保障，确保 PLC 一定被复位到安全状态。实际上大多数动作将 `cleanup` 设为 `null`，由 `stop` 负责正常复位即可。
-
----
-
-## Modbus 框架
-
-**核心文件**：`unilabos/device_comms/modbus_plc/client.py`
-**参考实现**：`unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`
-
-### 连接与节点注册
-
-```python
-from unilabos.device_comms.modbus_plc.client import TCPClient, BaseClient
-
-# 1. 建立 TCP 连接
-client = TCPClient(addr="172.16.28.102", port=502)
-client.client.connect()
-
-# 2. 从 CSV 加载节点定义
-nodes = BaseClient.load_csv("coin_cell_assembly_b.csv")
-
-# 3. 注册节点，之后可按名称访问
-client.register_node_list(nodes)
-
-# 访问节点
-client.use_node('COIL_SYS_START_CMD').write(True)
-value, err = client.use_node('COIL_SYS_START_STATUS').read(1)
-```
-
-**CSV 格式**（`Name` / `DeviceType` / `Address` / `DataType`）：
-
-| Name               | DeviceType    | Address | DataType |
-| ------------------ | ------------- | ------- | -------- |
-| COIL_SYS_START_CMD | coil          | 100     | INT16    |
-| REG_SPEED          | hold_register | 200     | FLOAT32  |
-
-### 三段式接管流程（扣式电池工站）
-
-PLC 设备通常需要按固定顺序切换模式，以扣式电池工站为例：
-
-```
-Python                             PLC
-  │── 写 HAND_CMD = True ─────────>│ 切换到手动模式
-  │<─ 读 HAND_STATUS = True ────────│ 确认进入手动
-  │── 写 INIT_CMD = True ──────────>│ 执行初始化
-  │<─ 读 INIT_STATUS = True ─────────│ 初始化完成
-  │── 写 HAND_CMD = False ──────────>│ 复位（脉冲信号）
-  │── 写 INIT_CMD = False ──────────>│ 复位
-  │── 写 AUTO_CMD = True ───────────>│ 切换自动模式
-  │<─ 读 AUTO_STATUS = True ─────────│ 自动模式就绪
-  │── 写 AUTO_CMD = False ──────────>│ 复位
-  │── 写 START_CMD = True ──────────>│ 开始运行
-  │<─ 读 START_STATUS = True ────────│ 运行确认
-  │── 写 START_CMD = False ──────────>│ 复位
-```
-
-> **脉冲信号模式**：命令写 `True` → 等待 PLC 状态位确认 → 命令写回 `False`，这是大多数 PLC 的标准触发方式，而不是保持高电平。
-
-### JSON 配置方式
-
-Modbus 框架支持纯 JSON 配置，无需手写 Python 流程：
-
-```json
-{
-    "register_node_list_from_csv_path": {"path": "M01.csv"},
-    "create_flow": [
-        {
-            "name": "归位",
-            "action": [{
-                "address_function_to_create": [
-                    {"func_name": "pos_tip",      "node_name": "M01_idlepos_coil_w",    "mode": "write", "value": true},
-                    {"func_name": "pos_tip_read", "node_name": "M01_idlepos_coil_r",    "mode": "read",  "value": 1},
-                    {"func_name": "manual_stop",  "node_name": "M01_manual_stop_coil_r","mode": "read",  "value": 1}
-                ],
-                "create_init_function":  {"func_name": "idel_init", "node_name": "M01_idlepos_velocity_rw", "mode": "write", "value": 20.0},
-                "create_start_function": {
-                    "func_name": "idel_position",
-                    "write_functions": ["pos_tip"],
-                    "condition_functions": ["pos_tip_read", "manual_stop"],
-                    "stop_condition_expression": "pos_tip_read[0] and manual_stop[0]"
-                },
-                "create_stop_function":  {"func_name": "idel_stop", "node_name": "M01_idlepos_coil_w", "mode": "write", "value": false},
-                "create_cleanup_function": null
-            }]
-        }
-    ],
-    "execute_flow": ["归位"]
-}
-```
-
-执行：
-
-```python
-client.execute_procedure_from_json(json_data)
-```
-
----
-
-## OPC UA 框架
-
-**核心文件**：`unilabos/devices/workstation/post_process/post_process.py`
-**参考实现**：`unilabos/devices/workstation/post_process/opcua_huairou.json`
-
-### 与 Modbus 的主要区别
-
-| 特性       | Modbus               | OPC UA                            |
-| ---------- | -------------------- | --------------------------------- |
-| 节点发现   | 手动填写 CSV 地址    | **自动遍历**服务器节点树          |
-| 数据获取   | 轮询（主动问）       | **订阅推送**（有变化时通知）      |
-| 节点标识   | 数字地址（如 `100`） | 字符串 NodeId（如 `ns=2;s=速度`） |
-| 断线处理   | 无                   | **后台监控线程**自动重连          |
-| 认证安全   | 无                   | 支持用户名/密码                   |
-| 工作流调用 | 手动调用             | **自动注册为实例方法**            |
-
-### 连接与节点发现
-
-```python
-from unilabos.devices.workstation.post_process.post_process import OpcUaClient
-
-client = OpcUaClient(
-    url="opc.tcp://192.168.1.100:4840",
-    username="admin",              # 可选
-    password="123456",             # 可选
-    config_path="opcua_huairou.json",  # 自动加载工作流配置
-    cache_timeout=5.0,             # 节点值缓存 5 秒
-    subscription_interval=500,     # 每 500ms 接收推送
-)
-
-# 节点自动通过订阅保持最新值，读取直接查本地缓存
-value = client.get_node_value("grab_complete")
-```
-
-### JSON 配置方式
-
-```json
-{
-    "register_node_list_from_csv_path": {"path": "opcua_nodes_huairou.csv"},
-    "create_flow": [
-        {
-            "name": "trigger_grab_action",
-            "description": "触发反应罐及原料罐抓取动作",
-            "parameters": ["reaction_tank_number", "raw_tank_number"],
-            "action": [{
-                "init_function": {
-                    "func_name": "init_grab_params",
-                    "write_nodes": ["reaction_tank_number", "raw_tank_number"]
-                },
-                "start_function": {
-                    "func_name": "start_grab",
-                    "write_nodes": {"grab_trigger": true},
-                    "condition_nodes": ["grab_complete"],
-                    "stop_condition_expression": "grab_complete == True",
-                    "timeout_seconds": 999999.0
-                },
-                "stop_function": {
-                    "func_name": "stop_grab",
-                    "write_nodes": {"grab_trigger": false}
-                }
-            }]
-        }
-    ]
-}
-```
-
-配置加载后，工作流自动注册为实例方法：
-
-```python
-# 直接调用，传入参数，框架自动写入对应节点
-client.trigger_grab_action(reaction_tank_number=2, raw_tank_number=3)
-```
-
----
-
-## 新增设备快速上手
-
-### 使用 Modbus 框架
-
-```
-1. 从 PLC 工程师处拿到地址表，按格式填写 CSV（Name/DeviceType/Address/DataType）
-2. 继承 BaseClient，在 __init__ 中连接并注册节点
-3. 参考 coin_cell_assembly.py 编写三段式接管函数（手动→初始化→自动→启动）
-4. 或直接编写 JSON 配置，调用 execute_procedure_from_json()
-```
-
-### 使用 OPC UA 框架
-
-```
-1. 确认设备支持 OPC UA，拿到服务器 URL（格式：opc.tcp://IP:PORT）
-2. 准备 CSV 节点定义文件（可选，也可让框架自动发现）
-3. 编写 JSON 配置：定义 parameters、init/start/stop 函数
-4. 实例化 OpcUaClient，传入 config_path，直接调用自动注册的工作流方法
-```
-
----
-
-## 常见问题
-
-**Q: `node {name} is not registered` 报错？**
-A: 节点名不在 CSV 或未调用 `register_node_list_from_csv_path()`。
-
-**Q: 程序卡死在 `while not status(): sleep(1)`？**
-A: PLC 未返回预期完成信号。检查：PLC 是否在正确运行模式、状态位地址是否正确、PLC 有无报警。
-
-**Q: OPC UA 连接成功但读不到节点？**
-A: 检查节点名称是否与服务器显示名一致（区分中英文）。可调用 `_find_nodes()` 打印服务器全部节点。
-
-**Q: 应该选 Modbus 还是 OPC UA？**
-A: 取决于设备支持的协议，由 PLC 工程师决定。OPC UA 功能更完整，条件允许优先选择。
-
----
-
-## 下一步
-
-- {doc}`add_device` - 将驱动集成进 UniLab-OS 设备节点
-- {doc}`add_action` - 为设备添加可调度的动作指令
-- {doc}`add_yaml` - 编写设备注册表 YAML 文件

docs/index.md

@@ -17,9 +17,6 @@ developer_guide/http_api.md
 developer_guide/networking_overview.md
 developer_guide/add_device.md
 developer_guide/add_action.md
-developer_guide/add_old_device.md
-developer_guide/plc_framework.md
-developer_guide/add_protocol.md
 developer_guide/add_registry.md
 developer_guide/add_yaml.md
 developer_guide/action_includes.md

docs/user_guide/best_practice.md

@@ -33,11 +33,11 @@
 
 **选择合适的安装包：**
 
-| 安装包          | 适用场景                     | 包含组件                                      |
-| --------------- | ---------------------------- | --------------------------------------------- |
-| `unilabos`      | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用                          |
-| `unilabos-env`  | 开发者（可编辑安装）         | 仅环境依赖，通过 pip 安装 unilabos            |
-| `unilabos-full` | 仿真/可视化                  | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |
+| 安装包 | 适用场景 | 包含组件 |
+|--------|----------|----------|
+| `unilabos` | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 |
+| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
+| `unilabos-full` | 仿真/可视化 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |
 
 **关键步骤：**
 
@@ -66,7 +66,6 @@ mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
 
 **选择建议：**
-
 - **日常使用/生产部署**：使用 `unilabos`（推荐），完整功能，开箱即用
 - **开发者**：使用 `unilabos-env` + `pip install -e .` + `uv pip install -r unilabos/utils/requirements.txt`，代码修改立即生效
 - **仿真/可视化**：使用 `unilabos-full`，含 Gazebo、rviz2、MoveIt
@@ -89,7 +88,7 @@ python -c "from unilabos_msgs.msg import Resource; print('ROS msgs OK')"
 
 #### 2.1 注册实验室账号
 
-1. 访问 [https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+1. 访问 [https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 2. 注册账号并登录
 3. 创建新实验室
 
@@ -298,7 +297,7 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 
 #### 5.2 访问 Web 界面
 
-启动系统后，访问[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+启动系统后，访问[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 
 #### 5.3 添加设备和物料
 
@@ -307,10 +306,12 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **示例场景：** 创建一个简单的液体转移实验
 
 1. **添加工作站（必需）：**
+
    - 在"仪器设备"中找到 `work_station`
    - 添加 `workstation` x1
 
 2. **添加虚拟转移泵：**
+
    - 在"仪器设备"中找到 `virtual_device`
    - 添加 `virtual_transfer_pump` x1
 
@@ -817,7 +818,6 @@ uv pip install -r unilabos/utils/requirements.txt
 ```
 
 **为什么使用这种方式？**
-
 - `unilabos-env` 提供 ROS2 核心组件和 uv（通过 conda 安装，避免编译）
 - `unilabos/utils/requirements.txt` 包含所有运行时需要的 pip 依赖
 - `dev_install.py` 自动检测中文环境，中文系统自动使用清华镜像
@@ -1796,27 +1796,32 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 **详细步骤：**
 
 1. **需求分析**：
+
    - 明确实验流程
    - 列出所需设备和物料
    - 设计工作流程图
 
 2. **环境搭建**：
+
    - 安装 Uni-Lab-OS
    - 创建实验室账号
    - 准备开发工具（IDE、Git）
 
 3. **原型验证**：
+
    - 使用虚拟设备测试流程
    - 验证工作流逻辑
    - 调整参数
 
 4. **迭代开发**：
+
    - 实现自定义设备驱动（同时撰写单点函数测试）
    - 编写注册表
    - 单元测试
    - 集成测试
 
 5. **测试部署**：
+
    - 连接真实硬件
    - 空跑测试
    - 小规模试验
@@ -1866,7 +1871,7 @@ unilab --ak your_ak --sk your_sk -g graph.json \
 #### 14.5 社区支持
 
 - **GitHub Issues**：[https://github.com/deepmodeling/Uni-Lab-OS/issues](https://github.com/deepmodeling/Uni-Lab-OS/issues)
-- **官方网站**：[https://leap-lab.bohrium.com](https://leap-lab.bohrium.com)
+- **官方网站**：[https://uni-lab.bohrium.com](https://uni-lab.bohrium.com)
 
 ---
 

docs/user_guide/graph_files.md

@@ -626,7 +626,7 @@ unilab
 
 **云端图文件管理**:
 
-1. 登录 https://leap-lab.bohrium.com
+1. 登录 https://uni-lab.bohrium.com
 2. 进入"设备配置"
 3. 创建或编辑配置
 4. 保存到云端

docs/user_guide/launch.md

@@ -54,6 +54,7 @@ Uni-Lab 的启动过程分为以下几个阶段：
 您可以直接跟随 unilabos 的提示进行，无需查阅本节
 
 - **工作目录设置**：
+
   - 如果当前目录以 `unilabos_data` 结尾，则使用当前目录
   - 否则使用 `当前目录/unilabos_data` 作为工作目录
   - 可通过 `--working_dir` 指定自定义工作目录
@@ -67,8 +68,8 @@ Uni-Lab 的启动过程分为以下几个阶段：
 
 支持多种后端环境：
 
-- `--addr test`：测试环境 (`https://leap-lab.test.bohrium.com/api/v1`)
-- `--addr uat`：UAT 环境 (`https://leap-lab.uat.bohrium.com/api/v1`)
+- `--addr test`：测试环境 (`https://uni-lab.test.bohrium.com/api/v1`)
+- `--addr uat`：UAT 环境 (`https://uni-lab.uat.bohrium.com/api/v1`)
 - `--addr local`：本地环境 (`http://127.0.0.1:48197/api/v1`)
 - 自定义地址：直接指定完整 URL
 
@@ -175,7 +176,7 @@ unilab --config path/to/your/config.py
 
 如果是首次使用，系统会：
 
-1. 提示前往 https://leap-lab.bohrium.com 注册实验室
+1. 提示前往 https://uni-lab.bohrium.com 注册实验室
 2. 引导创建配置文件
 3. 设置工作目录
 
@@ -215,7 +216,7 @@ unilab --ak your_ak --sk your_sk --port 8080 --disable_browser
 
 如果提示 "后续运行必须拥有一个实验室"，请确保：
 
-- 已在 https://leap-lab.bohrium.com 注册实验室
+- 已在 https://uni-lab.bohrium.com 注册实验室
 - 正确设置了 `--ak` 和 `--sk` 参数
 - 配置文件中包含正确的认证信息
 

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.11.1
+  version: 0.10.19
 source:
   path: ../../unilabos_msgs
   target_directory: src

recipes/unilabos/recipe.yaml

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

setup.py

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

test/devices/test_prcxi.py

@@ -0,0 +1,539 @@
+import pytest
+import json
+import os
+import asyncio
+import collections
+from typing import List, Dict, Any
+
+from pylabrobot.resources import Coordinate
+from pylabrobot.resources.opentrons.tip_racks import opentrons_96_tiprack_300ul, opentrons_96_tiprack_10ul
+from pylabrobot.resources.opentrons.plates import corning_96_wellplate_360ul_flat, nest_96_wellplate_2ml_deep
+
+from unilabos.devices.liquid_handling.prcxi.prcxi import (
+    PRCXI9300Deck,
+    PRCXI9300Container,
+    PRCXI9300Trash,
+    PRCXI9300Handler,
+    PRCXI9300Backend,
+    DefaultLayout,
+    Material,
+    WorkTablets,
+    MatrixInfo
+)
+
+
+@pytest.fixture
+def prcxi_materials() -> Dict[str, Any]:
+    """加载 PRCXI 物料数据"""
+    print("加载 PRCXI 物料数据...")
+    material_path = os.path.join(os.path.dirname(__file__), "..", "..", "unilabos", "devices", "liquid_handling", "prcxi", "prcxi_material.json")
+    with open(material_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+@pytest.fixture
+def prcxi_9300_deck() -> PRCXI9300Deck:
+    """创建 PRCXI 9300 工作台"""
+    return PRCXI9300Deck(name="PRCXI_Deck_9300", size_x=100, size_y=100, size_z=100, model="9300")
+
+
+@pytest.fixture
+def prcxi_9320_deck() -> PRCXI9300Deck:
+    """创建 PRCXI 9320 工作台"""
+    return PRCXI9300Deck(name="PRCXI_Deck_9320", size_x=100, size_y=100, size_z=100, model="9320")
+
+
+@pytest.fixture
+def prcxi_9300_handler(prcxi_9300_deck) -> PRCXI9300Handler:
+    """创建 PRCXI 9300 处理器（模拟模式）"""
+    return PRCXI9300Handler(
+        deck=prcxi_9300_deck,
+        host="192.168.1.201",
+        port=9999,
+        timeout=10.0,
+        channel_num=8,
+        axis="Left",
+        setup=False,
+        debug=True,
+        simulator=True,
+        matrix_id="test-matrix-9300"
+    )
+
+
+@pytest.fixture
+def prcxi_9320_handler(prcxi_9320_deck) -> PRCXI9300Handler:
+    """创建 PRCXI 9320 处理器（模拟模式）"""
+    return PRCXI9300Handler(
+        deck=prcxi_9320_deck,
+        host="192.168.1.201",
+        port=9999,
+        timeout=10.0,
+        channel_num=1,
+        axis="Right",
+        setup=False,
+        debug=True,
+        simulator=True,
+        matrix_id="test-matrix-9320",
+        is_9320=True
+    )
+
+
+@pytest.fixture
+def tip_rack_300ul(prcxi_materials) -> PRCXI9300Container:
+    """创建 300μL 枪头盒"""
+    tip_rack = PRCXI9300Container(
+        name="tip_rack_300ul",
+        size_x=50,
+        size_y=50,
+        size_z=10,
+        category="tip_rack",
+        ordering=collections.OrderedDict()
+    )
+    tip_rack.load_state({
+        "Material": {
+            "uuid": prcxi_materials["300μL Tip头"]["uuid"],
+            "Code": "ZX-001-300",
+            "Name": "300μL Tip头"
+        }
+    })
+    return tip_rack
+
+
+@pytest.fixture
+def tip_rack_10ul(prcxi_materials) -> PRCXI9300Container:
+    """创建 10μL 枪头盒"""
+    tip_rack = PRCXI9300Container(
+        name="tip_rack_10ul",
+        size_x=50,
+        size_y=50,
+        size_z=10,
+        category="tip_rack",
+        ordering=collections.OrderedDict()
+    )
+    tip_rack.load_state({
+        "Material": {
+            "uuid": prcxi_materials["10μL加长 Tip头"]["uuid"],
+            "Code": "ZX-001-10+",
+            "Name": "10μL加长 Tip头"
+        }
+    })
+    return tip_rack
+
+
+@pytest.fixture
+def well_plate_96(prcxi_materials) -> PRCXI9300Container:
+    """创建 96 孔板"""
+    plate = PRCXI9300Container(
+        name="well_plate_96",
+        size_x=50,
+        size_y=50,
+        size_z=10,
+        category="plate",
+        ordering=collections.OrderedDict()
+    )
+    plate.load_state({
+        "Material": {
+            "uuid": prcxi_materials["96深孔板"]["uuid"],
+            "Code": "ZX-019-2.2",
+            "Name": "96深孔板"
+        }
+    })
+    return plate
+
+
+@pytest.fixture
+def deep_well_plate(prcxi_materials) -> PRCXI9300Container:
+    """创建深孔板"""
+    plate = PRCXI9300Container(
+        name="deep_well_plate",
+        size_x=50,
+        size_y=50,
+        size_z=10,
+        category="plate",
+        ordering=collections.OrderedDict()
+    )
+    plate.load_state({
+        "Material": {
+            "uuid": prcxi_materials["96深孔板"]["uuid"],
+            "Code": "ZX-019-2.2",
+            "Name": "96深孔板"
+        }
+    })
+    return plate
+
+
+@pytest.fixture
+def trash_container(prcxi_materials) -> PRCXI9300Trash:
+    """创建垃圾桶"""
+    trash = PRCXI9300Trash(name="trash", size_x=50, size_y=50, size_z=10, category="trash")
+    trash.load_state({
+        "Material": {
+            "uuid": prcxi_materials["废弃槽"]["uuid"]
+        }
+    })
+    return trash
+
+
+@pytest.fixture
+def default_layout_9300() -> DefaultLayout:
+    """创建 PRCXI 9300 默认布局"""
+    return DefaultLayout("PRCXI9300")
+
+
+@pytest.fixture
+def default_layout_9320() -> DefaultLayout:
+    """创建 PRCXI 9320 默认布局"""
+    return DefaultLayout("PRCXI9320")
+
+
+class TestPRCXIDeckSetup:
+    """测试 PRCXI 工作台设置功能"""
+
+    def test_prcxi_9300_deck_creation(self, prcxi_9300_deck):
+        """测试 PRCXI 9300 工作台创建"""
+        assert prcxi_9300_deck.name == "PRCXI_Deck_9300"
+        assert len(prcxi_9300_deck.sites) == 6
+        assert prcxi_9300_deck._size_x == 100
+        assert prcxi_9300_deck._size_y == 100
+        assert prcxi_9300_deck._size_z == 100
+
+    def test_prcxi_9320_deck_creation(self, prcxi_9320_deck):
+        """测试 PRCXI 9320 工作台创建"""
+        assert prcxi_9320_deck.name == "PRCXI_Deck_9320"
+        assert len(prcxi_9320_deck.sites) == 16
+        assert prcxi_9320_deck._size_x == 100
+        assert prcxi_9320_deck._size_y == 100
+        assert prcxi_9320_deck._size_z == 100
+
+    def test_container_assignment(self, prcxi_9300_deck, tip_rack_300ul, well_plate_96, trash_container):
+        """测试容器分配到工作台"""
+        # 分配枪头盒
+        prcxi_9300_deck.assign_child_resource(tip_rack_300ul, location=Coordinate(0, 0, 0))
+        assert tip_rack_300ul in prcxi_9300_deck.children
+        
+        # 分配孔板
+        prcxi_9300_deck.assign_child_resource(well_plate_96, location=Coordinate(0, 0, 0))
+        assert well_plate_96 in prcxi_9300_deck.children
+        
+        # 分配垃圾桶
+        prcxi_9300_deck.assign_child_resource(trash_container, location=Coordinate(0, 0, 0))
+        assert trash_container in prcxi_9300_deck.children
+
+    def test_container_material_loading(self, tip_rack_300ul, well_plate_96, prcxi_materials):
+        """测试容器物料信息加载"""
+        # 测试枪头盒物料信息
+        tip_material = tip_rack_300ul._unilabos_state["Material"]
+        assert tip_material["uuid"] == prcxi_materials["300μL Tip头"]["uuid"]
+        assert tip_material["Name"] == "300μL Tip头"
+        
+        # 测试孔板物料信息
+        plate_material = well_plate_96._unilabos_state["Material"]
+        assert plate_material["uuid"] == prcxi_materials["96深孔板"]["uuid"]
+        assert plate_material["Name"] == "96深孔板"
+
+
+class TestPRCXISingleStepOperations:
+    """测试 PRCXI 单步操作功能"""
+
+    @pytest.mark.asyncio
+    async def test_pick_up_tips_single_channel(self, prcxi_9320_handler, prcxi_9320_deck, tip_rack_10ul):
+        """测试单通道拾取枪头"""
+        # 将枪头盒添加到工作台
+        prcxi_9320_deck.assign_child_resource(tip_rack_10ul, location=Coordinate(0, 0, 0))
+        
+        # 初始化处理器
+        await prcxi_9320_handler.setup()
+        
+        # 设置枪头盒
+        prcxi_9320_handler.set_tiprack([tip_rack_10ul])
+        
+        # 创建模拟的枪头位置
+        from pylabrobot.resources import TipSpot, Tip
+        tip = Tip(has_filter=False, total_tip_length=10, maximal_volume=10, fitting_depth=5)
+        tip_spot = TipSpot("A1", size_x=1, size_y=1, size_z=1, make_tip=lambda: tip)
+        tip_rack_10ul.assign_child_resource(tip_spot, location=Coordinate(0, 0, 0))
+        
+        # 直接测试后端方法
+        from pylabrobot.liquid_handling import Pickup
+        pickup = Pickup(resource=tip_spot, offset=None, tip=tip)
+        await prcxi_9320_handler._unilabos_backend.pick_up_tips([pickup], [0])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "Load"
+
+    @pytest.mark.asyncio
+    async def test_pick_up_tips_multi_channel(self, prcxi_9300_handler, tip_rack_300ul):
+        """测试多通道拾取枪头"""
+        # 设置枪头盒
+        prcxi_9300_handler.set_tiprack([tip_rack_300ul])
+        
+        # 拾取8个枪头
+        tip_spots = tip_rack_300ul.children[:8]
+        await prcxi_9300_handler.pick_up_tips(tip_spots, [0, 1, 2, 3, 4, 5, 6, 7])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9300_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9300_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "Load"
+
+    @pytest.mark.asyncio
+    async def test_aspirate_single_channel(self, prcxi_9320_handler, well_plate_96):
+        """测试单通道吸取液体"""
+        # 设置液体
+        well = well_plate_96.get_item("A1")
+        prcxi_9320_handler.set_liquid([well], ["water"], [50])
+        
+        # 吸取液体
+        await prcxi_9320_handler.aspirate([well], [50], [0])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "Imbibing"
+        assert step["DosageNum"] == 50
+
+    @pytest.mark.asyncio
+    async def test_dispense_single_channel(self, prcxi_9320_handler, well_plate_96):
+        """测试单通道分配液体"""
+        # 分配液体
+        well = well_plate_96.get_item("A1")
+        await prcxi_9320_handler.dispense([well], [25], [0])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "Tapping"
+        assert step["DosageNum"] == 25
+
+    @pytest.mark.asyncio
+    async def test_mix_single_channel(self, prcxi_9320_handler, well_plate_96):
+        """测试单通道混合液体"""
+        # 混合液体
+        well = well_plate_96.get_item("A1")
+        await prcxi_9320_handler.mix([well], mix_time=3, mix_vol=50)
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "Blending"
+        assert step["BlendingTimes"] == 3
+        assert step["DosageNum"] == 50
+
+    @pytest.mark.asyncio
+    async def test_drop_tips_to_trash(self, prcxi_9320_handler, trash_container):
+        """测试丢弃枪头到垃圾桶"""
+        # 丢弃枪头
+        await prcxi_9320_handler.drop_tips([trash_container], [0])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "UnLoad"
+
+    @pytest.mark.asyncio
+    async def test_discard_tips(self, prcxi_9320_handler):
+        """测试丢弃枪头"""
+        # 丢弃枪头
+        await prcxi_9320_handler.discard_tips([0])
+        
+        # 验证步骤已添加到待办列表
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 1
+        step = prcxi_9320_handler._unilabos_backend.steps_todo_list[0]
+        assert step["Function"] == "UnLoad"
+
+    @pytest.mark.asyncio
+    async def test_liquid_transfer_workflow(self, prcxi_9320_handler, tip_rack_10ul, well_plate_96):
+        """测试完整的液体转移工作流程"""
+        # 设置枪头盒和液体
+        prcxi_9320_handler.set_tiprack([tip_rack_10ul])
+        source_well = well_plate_96.get_item("A1")
+        target_well = well_plate_96.get_item("B1")
+        prcxi_9320_handler.set_liquid([source_well], ["water"], [100])
+        
+        # 创建协议
+        await prcxi_9320_handler.create_protocol(protocol_name="Test Transfer Protocol")
+        
+        # 执行转移流程
+        tip_spot = tip_rack_10ul.get_item("A1")
+        await prcxi_9320_handler.pick_up_tips([tip_spot], [0])
+        await prcxi_9320_handler.aspirate([source_well], [50], [0])
+        await prcxi_9320_handler.dispense([target_well], [50], [0])
+        await prcxi_9320_handler.discard_tips([0])
+        
+        # 验证所有步骤都已添加
+        assert len(prcxi_9320_handler._unilabos_backend.steps_todo_list) == 4
+        functions = [step["Function"] for step in prcxi_9320_handler._unilabos_backend.steps_todo_list]
+        assert functions == ["Load", "Imbibing", "Tapping", "UnLoad"]
+
+
+class TestPRCXILayoutRecommendation:
+    """测试 PRCXI 板位推荐功能"""
+
+    def test_9300_layout_creation(self, default_layout_9300):
+        """测试 PRCXI 9300 布局创建"""
+        layout_info = default_layout_9300.get_layout()
+        assert layout_info["rows"] == 2
+        assert layout_info["columns"] == 3
+        assert len(layout_info["layout"]) == 6
+        assert layout_info["trash_slot"] == 6
+        assert "waste_liquid_slot" not in layout_info
+
+    def test_9320_layout_creation(self, default_layout_9320):
+        """测试 PRCXI 9320 布局创建"""
+        layout_info = default_layout_9320.get_layout()
+        assert layout_info["rows"] == 4
+        assert layout_info["columns"] == 4
+        assert len(layout_info["layout"]) == 16
+        assert layout_info["trash_slot"] == 16
+        assert layout_info["waste_liquid_slot"] == 12
+
+    def test_layout_recommendation_9320(self, default_layout_9320, prcxi_materials):
+        """测试 PRCXI 9320 板位推荐功能"""
+        # 添加物料信息
+        default_layout_9320.add_lab_resource(prcxi_materials)
+        
+        # 推荐布局
+        needs = [
+            ("reagent_1", "96 细胞培养皿", 3),
+            ("reagent_2", "12道储液槽", 1),
+            ("reagent_3", "200μL Tip头", 7),
+            ("reagent_4", "10μL加长 Tip头", 1),
+        ]
+        
+        matrix_layout, layout_list = default_layout_9320.recommend_layout(needs)
+        
+        # 验证返回结果
+        assert "MatrixId" in matrix_layout
+        assert "MatrixName" in matrix_layout
+        assert "MatrixCount" in matrix_layout
+        assert "WorkTablets" in matrix_layout
+        assert len(layout_list) == 12  # 3+1+7+1 = 12个位置
+        
+        # 验证推荐的位置不包含预留位置
+        reserved_positions = {12, 16}
+        recommended_positions = [item["positions"] for item in layout_list]
+        for pos in recommended_positions:
+            assert pos not in reserved_positions
+
+    def test_layout_recommendation_insufficient_space(self, default_layout_9320, prcxi_materials):
+        """测试板位推荐空间不足的情况"""
+        # 添加物料信息
+        default_layout_9320.add_lab_resource(prcxi_materials)
+        
+        # 尝试推荐超过可用空间的布局
+        needs = [
+            ("reagent_1", "96 细胞培养皿", 15),  # 需要15个位置，但只有14个可用
+        ]
+        
+        with pytest.raises(ValueError, match="需要 .* 个位置，但只有 .* 个可用位置"):
+            default_layout_9320.recommend_layout(needs)
+
+    def test_layout_recommendation_material_not_found(self, default_layout_9320, prcxi_materials):
+        """测试板位推荐物料不存在的情况"""
+        # 添加物料信息
+        default_layout_9320.add_lab_resource(prcxi_materials)
+        
+        # 尝试推荐不存在的物料
+        needs = [
+            ("reagent_1", "不存在的物料", 1),
+        ]
+        
+        with pytest.raises(ValueError, match="Material .* not found in lab resources"):
+            default_layout_9320.recommend_layout(needs)
+
+
+class TestPRCXIBackendOperations:
+    """测试 PRCXI 后端操作功能"""
+
+    def test_backend_initialization(self, prcxi_9300_handler):
+        """测试后端初始化"""
+        backend = prcxi_9300_handler._unilabos_backend
+        assert isinstance(backend, PRCXI9300Backend)
+        assert backend._num_channels == 8
+        assert backend.debug is True
+
+    def test_protocol_creation(self, prcxi_9300_handler):
+        """测试协议创建"""
+        backend = prcxi_9300_handler._unilabos_backend
+        backend.create_protocol("Test Protocol")
+        assert backend.protocol_name == "Test Protocol"
+        assert len(backend.steps_todo_list) == 0
+
+    def test_channel_validation(self):
+        """测试通道验证"""
+        # 测试正确的8通道配置
+        valid_channels = [0, 1, 2, 3, 4, 5, 6, 7]
+        result = PRCXI9300Backend.check_channels(valid_channels)
+        assert result == valid_channels
+        
+        # 测试错误的通道配置
+        invalid_channels = [0, 1, 2, 3]
+        result = PRCXI9300Backend.check_channels(invalid_channels)
+        assert result == [0, 1, 2, 3, 4, 5, 6, 7]
+
+    def test_matrix_info_creation(self, prcxi_9300_handler):
+        """测试矩阵信息创建"""
+        backend = prcxi_9300_handler._unilabos_backend
+        backend.create_protocol("Test Protocol")
+        
+        # 模拟运行协议时的矩阵信息创建
+        run_time = 1234567890
+        matrix_info = MatrixInfo(
+            MatrixId=f"{int(run_time)}",
+            MatrixName=f"protocol_{run_time}",
+            MatrixCount=len(backend.tablets_info),
+            WorkTablets=backend.tablets_info,
+        )
+        
+        assert matrix_info["MatrixId"] == str(int(run_time))
+        assert matrix_info["MatrixName"] == f"protocol_{run_time}"
+        assert "WorkTablets" in matrix_info
+
+
+class TestPRCXIContainerOperations:
+    """测试 PRCXI 容器操作功能"""
+
+    def test_container_serialization(self, tip_rack_300ul):
+        """测试容器序列化"""
+        serialized = tip_rack_300ul.serialize_state()
+        assert "Material" in serialized
+        assert serialized["Material"]["Name"] == "300μL Tip头"
+
+    def test_container_deserialization(self, tip_rack_300ul):
+        """测试容器反序列化"""
+        # 序列化
+        serialized = tip_rack_300ul.serialize_state()
+        
+        # 创建新容器并反序列化
+        new_tip_rack = PRCXI9300Container(
+            name="new_tip_rack",
+            size_x=50,
+            size_y=50,
+            size_z=10,
+            category="tip_rack",
+            ordering=collections.OrderedDict()
+        )
+        new_tip_rack.load_state(serialized)
+        
+        assert new_tip_rack._unilabos_state["Material"]["Name"] == "300μL Tip头"
+
+    def test_trash_container_creation(self, prcxi_materials):
+        """测试垃圾桶容器创建"""
+        trash = PRCXI9300Trash(name="trash", size_x=50, size_y=50, size_z=10, category="trash")
+        trash.load_state({
+            "Material": {
+                "uuid": prcxi_materials["废弃槽"]["uuid"]
+            }
+        })
+        
+        assert trash.name == "trash"
+        assert trash._unilabos_state["Material"]["uuid"] == prcxi_materials["废弃槽"]["uuid"]
+
+
+if __name__ == "__main__":
+    # 运行测试
+    pytest.main([__file__, "-v"])

tests/devices/liquid_handling/README.md

@@ -0,0 +1,15 @@
+# Liquid handling 集成测试
+
+`test_transfer_liquid.py` 现在会调用 PRCXI 的 RViz 仿真 backend，运行前请确保：
+
+1. 已安装包含 `pylabrobot`、`rclpy` 的运行环境；
+2. 启动 ROS 依赖（`rviz` 可选，但是 `rviz_backend` 会创建 ROS 节点）；
+3. 在 shell 中设置 `UNILAB_SIM_TEST=1`，否则 pytest 会自动跳过这些慢速用例：
+
+```bash
+export UNILAB_SIM_TEST=1
+pytest tests/devices/liquid_handling/test_transfer_liquid.py -m slow
+```
+
+如果只需验证逻辑层（不依赖仿真），可以直接运行 `tests/devices/liquid_handling/unit_test.py`，该文件使用 Fake backend，适合作为 CI 的快速测试。***
+

tests/devices/liquid_handling/unit_test.py

@@ -0,0 +1,547 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Iterable, List, Optional, Sequence, Tuple
+
+import pytest
+
+from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
+
+
+@dataclass(frozen=True)
+class DummyContainer:
+    name: str
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"DummyContainer({self.name})"
+
+
+@dataclass(frozen=True)
+class DummyTipSpot:
+    name: str
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"DummyTipSpot({self.name})"
+
+
+def make_tip_iter(n: int = 256) -> Iterable[List[DummyTipSpot]]:
+    """Yield lists so code can safely call `tip.extend(next(self.current_tip))`."""
+    for i in range(n):
+        yield [DummyTipSpot(f"tip_{i}")]
+
+
+class FakeLiquidHandler(LiquidHandlerAbstract):
+    """不初始化真实 backend/deck；仅用来记录 transfer_liquid 内部调用序列。"""
+
+    def __init__(self, channel_num: int = 8):
+        # 不调用 super().__init__，避免真实硬件/后端依赖
+        self.channel_num = channel_num
+        self.support_touch_tip = True
+        self.current_tip = iter(make_tip_iter())
+        self.calls: List[Tuple[str, Any]] = []
+
+    async def pick_up_tips(self, tip_spots, use_channels=None, offsets=None, **backend_kwargs):
+        self.calls.append(("pick_up_tips", {"tips": list(tip_spots), "use_channels": use_channels}))
+
+    async def aspirate(
+        self,
+        resources: Sequence[Any],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Any = None,
+        liquid_height: Any = None,
+        blow_out_air_volume: Any = None,
+        spread: str = "wide",
+        **backend_kwargs,
+    ):
+        self.calls.append(
+            (
+                "aspirate",
+                {
+                    "resources": list(resources),
+                    "vols": list(vols),
+                    "use_channels": list(use_channels) if use_channels is not None else None,
+                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
+                    "offsets": list(offsets) if offsets is not None else None,
+                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
+                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
+                },
+            )
+        )
+
+    async def dispense(
+        self,
+        resources: Sequence[Any],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Any = None,
+        liquid_height: Any = None,
+        blow_out_air_volume: Any = None,
+        spread: str = "wide",
+        **backend_kwargs,
+    ):
+        self.calls.append(
+            (
+                "dispense",
+                {
+                    "resources": list(resources),
+                    "vols": list(vols),
+                    "use_channels": list(use_channels) if use_channels is not None else None,
+                    "flow_rates": list(flow_rates) if flow_rates is not None else None,
+                    "offsets": list(offsets) if offsets is not None else None,
+                    "liquid_height": list(liquid_height) if liquid_height is not None else None,
+                    "blow_out_air_volume": list(blow_out_air_volume) if blow_out_air_volume is not None else None,
+                },
+            )
+        )
+
+    async def discard_tips(self, use_channels=None, *args, **kwargs):
+        # 有的分支是 discard_tips(use_channels=[0])，有的分支是 discard_tips([0..7])（位置参数）
+        self.calls.append(("discard_tips", {"use_channels": list(use_channels) if use_channels is not None else None}))
+
+    async def custom_delay(self, seconds=0, msg=None):
+        self.calls.append(("custom_delay", {"seconds": seconds, "msg": msg}))
+
+    async def touch_tip(self, targets):
+        # 原实现会访问 targets.get_size_x() 等；测试里只记录调用
+        self.calls.append(("touch_tip", {"targets": targets}))
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+def test_one_to_one_single_channel_basic_calls():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  targets = [DummyContainer(f"T{i}") for i in range(3)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[1, 2, 3],
+      dis_vols=[4, 5, 6],
+      mix_times=None,  # 应该仍能执行（不 mix）
+    )
+  )
+
+  assert [c[0] for c in lh.calls].count("pick_up_tips") == 3
+  assert [c[0] for c in lh.calls].count("aspirate") == 3
+  assert [c[0] for c in lh.calls].count("dispense") == 3
+  assert [c[0] for c in lh.calls].count("discard_tips") == 3
+
+  # 每次 aspirate/dispense 都是单孔列表
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert aspirates[0]["resources"] == [sources[0]]
+  assert aspirates[0]["vols"] == [1.0]
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert dispenses[2]["resources"] == [targets[2]]
+  assert dispenses[2]["vols"] == [6.0]
+
+
+def test_one_to_one_single_channel_before_stage_mixes_prior_to_aspirate():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(16))
+
+  source = DummyContainer("S0")
+  target = DummyContainer("T0")
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[5],
+      dis_vols=[5],
+      mix_stage="before",
+      mix_times=1,
+      mix_vol=3,
+    )
+  )
+
+  aspirate_calls = [(idx, payload) for idx, (name, payload) in enumerate(lh.calls) if name == "aspirate"]
+  assert len(aspirate_calls) >= 2
+  mix_idx, mix_payload = aspirate_calls[0]
+  assert mix_payload["resources"] == [target]
+  assert mix_payload["vols"] == [3]
+  transfer_idx, transfer_payload = aspirate_calls[1]
+  assert transfer_payload["resources"] == [source]
+  assert mix_idx < transfer_idx
+
+
+def test_one_to_one_eight_channel_groups_by_8():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(256))
+
+  sources = [DummyContainer(f"S{i}") for i in range(16)]
+  targets = [DummyContainer(f"T{i}") for i in range(16)]
+  asp_vols = list(range(1, 17))
+  dis_vols = list(range(101, 117))
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      mix_times=0,  # 触发逻辑但不 mix
+    )
+  )
+
+  # 16 个任务 -> 2 组，每组 8 通道一起做
+  assert [c[0] for c in lh.calls].count("pick_up_tips") == 2
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == 2
+  assert len(dispenses) == 2
+
+  assert aspirates[0]["resources"] == sources[0:8]
+  assert aspirates[0]["vols"] == [float(v) for v in asp_vols[0:8]]
+  assert dispenses[1]["resources"] == targets[8:16]
+  assert dispenses[1]["vols"] == [float(v) for v in dis_vols[8:16]]
+
+
+def test_one_to_one_eight_channel_requires_multiple_of_8_targets():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer(f"S{i}") for i in range(9)]
+  targets = [DummyContainer(f"T{i}") for i in range(9)]
+
+  with pytest.raises(ValueError, match="multiple of 8"):
+    run(
+      lh.transfer_liquid(
+        sources=sources,
+        targets=targets,
+        tip_racks=[],
+        use_channels=list(range(8)),
+        asp_vols=[1] * 9,
+        dis_vols=[1] * 9,
+        mix_times=0,
+      )
+    )
+
+
+def test_one_to_one_eight_channel_parameter_lists_are_chunked_per_8():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(512))
+
+  sources = [DummyContainer(f"S{i}") for i in range(16)]
+  targets = [DummyContainer(f"T{i}") for i in range(16)]
+  asp_vols = [i + 1 for i in range(16)]
+  dis_vols = [200 + i for i in range(16)]
+  asp_flow_rates = [0.1 * (i + 1) for i in range(16)]
+  dis_flow_rates = [0.2 * (i + 1) for i in range(16)]
+  offsets = [f"offset_{i}" for i in range(16)]
+  liquid_heights = [i * 0.5 for i in range(16)]
+  blow_out_air_volume = [i + 0.05 for i in range(16)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      asp_flow_rates=asp_flow_rates,
+      dis_flow_rates=dis_flow_rates,
+      offsets=offsets,
+      liquid_height=liquid_heights,
+      blow_out_air_volume=blow_out_air_volume,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == len(dispenses) == 2
+
+  for batch_idx in range(2):
+    start = batch_idx * 8
+    end = start + 8
+    asp_call = aspirates[batch_idx]
+    dis_call = dispenses[batch_idx]
+    assert asp_call["resources"] == sources[start:end]
+    assert asp_call["flow_rates"] == asp_flow_rates[start:end]
+    assert asp_call["offsets"] == offsets[start:end]
+    assert asp_call["liquid_height"] == liquid_heights[start:end]
+    assert asp_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
+    assert dis_call["flow_rates"] == dis_flow_rates[start:end]
+    assert dis_call["offsets"] == offsets[start:end]
+    assert dis_call["liquid_height"] == liquid_heights[start:end]
+    assert dis_call["blow_out_air_volume"] == blow_out_air_volume[start:end]
+
+
+def test_one_to_one_eight_channel_handles_32_tasks_four_batches():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(1024))
+
+  sources = [DummyContainer(f"S{i}") for i in range(32)]
+  targets = [DummyContainer(f"T{i}") for i in range(32)]
+  asp_vols = [i + 1 for i in range(32)]
+  dis_vols = [300 + i for i in range(32)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  pick_calls = [name for name, _ in lh.calls if name == "pick_up_tips"]
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(pick_calls) == 4
+  assert len(aspirates) == len(dispenses) == 4
+  assert aspirates[0]["resources"] == sources[0:8]
+  assert aspirates[-1]["resources"] == sources[24:32]
+  assert dispenses[0]["resources"] == targets[0:8]
+  assert dispenses[-1]["resources"] == targets[24:32]
+
+
+def test_one_to_many_single_channel_aspirates_total_when_asp_vol_too_small():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  source = DummyContainer("SRC")
+  targets = [DummyContainer(f"T{i}") for i in range(3)]
+  dis_vols = [10, 20, 30]  # sum=60
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=targets,
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=10,  # 小于 sum(dis_vols) -> 应吸 60
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert len(aspirates) == 1
+  assert aspirates[0]["resources"] == [source]
+  assert aspirates[0]["vols"] == [60.0]
+  assert aspirates[0]["use_channels"] == [0]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [10.0, 20.0, 30.0]
+
+
+def test_one_to_many_eight_channel_basic():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  source = DummyContainer("SRC")
+  targets = [DummyContainer(f"T{i}") for i in range(8)]
+  dis_vols = [i + 1 for i in range(8)]
+
+  run(
+    lh.transfer_liquid(
+      sources=[source],
+      targets=targets,
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=999,  # one-to-many 8ch 会按 dis_vols 吸（每通道各自）
+      dis_vols=dis_vols,
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert aspirates[0]["resources"] == [source] * 8
+  assert aspirates[0]["vols"] == [float(v) for v in dis_vols]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert dispenses[0]["resources"] == targets
+  assert dispenses[0]["vols"] == [float(v) for v in dis_vols]
+
+
+def test_many_to_one_single_channel_standard_dispense_equals_asp_by_default():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  target = DummyContainer("T")
+  asp_vols = [5, 6, 7]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=asp_vols,
+      dis_vols=1,  # many-to-one 允许标量；非比例模式下实际每次分液=对应 asp_vol
+      mix_times=0,
+    )
+  )
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [float(v) for v in asp_vols]
+  assert all(d["resources"] == [target] for d in dispenses)
+
+
+def test_many_to_one_single_channel_before_stage_mixes_target_once():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer("S0"), DummyContainer("S1")]
+  target = DummyContainer("T")
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=[5, 6],
+      dis_vols=1,
+      mix_stage="before",
+      mix_times=2,
+      mix_vol=4,
+    )
+  )
+
+  aspirate_calls = [(idx, payload) for idx, (name, payload) in enumerate(lh.calls) if name == "aspirate"]
+  assert len(aspirate_calls) >= 1
+  mix_idx, mix_payload = aspirate_calls[0]
+  assert mix_payload["resources"] == [target]
+  assert mix_payload["vols"] == [4]
+  # 第一個 mix 之後會真正開始吸 source
+  assert any(call["resources"] == [sources[0]] for _, call in aspirate_calls[1:])
+
+
+def test_many_to_one_single_channel_proportional_mixing_uses_dis_vols_per_source():
+  lh = FakeLiquidHandler(channel_num=1)
+  lh.current_tip = iter(make_tip_iter(128))
+
+  sources = [DummyContainer(f"S{i}") for i in range(3)]
+  target = DummyContainer("T")
+  asp_vols = [5, 6, 7]
+  dis_vols = [1, 2, 3]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=[0],
+      asp_vols=asp_vols,
+      dis_vols=dis_vols,  # 比例模式
+      mix_times=0,
+    )
+  )
+
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert [d["vols"][0] for d in dispenses] == [float(v) for v in dis_vols]
+
+
+def test_many_to_one_eight_channel_basic():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(256))
+
+  sources = [DummyContainer(f"S{i}") for i in range(8)]
+  target = DummyContainer("T")
+  asp_vols = [10 + i for i in range(8)]
+
+  run(
+    lh.transfer_liquid(
+      sources=sources,
+      targets=[target],
+      tip_racks=[],
+      use_channels=list(range(8)),
+      asp_vols=asp_vols,
+      dis_vols=999,  # 非比例模式下每通道分液=对应 asp_vol
+      mix_times=0,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert aspirates[0]["resources"] == sources
+  assert aspirates[0]["vols"] == [float(v) for v in asp_vols]
+  assert dispenses[0]["resources"] == [target] * 8
+  assert dispenses[0]["vols"] == [float(v) for v in asp_vols]
+
+
+def test_transfer_liquid_mode_detection_unsupported_shape_raises():
+  lh = FakeLiquidHandler(channel_num=8)
+  lh.current_tip = iter(make_tip_iter(64))
+
+  sources = [DummyContainer("S0"), DummyContainer("S1")]
+  targets = [DummyContainer("T0"), DummyContainer("T1"), DummyContainer("T2")]
+
+  with pytest.raises(ValueError, match="Unsupported transfer mode"):
+    run(
+      lh.transfer_liquid(
+        sources=sources,
+        targets=targets,
+        tip_racks=[],
+        use_channels=[0],
+        asp_vols=[1, 1],
+        dis_vols=[1, 1, 1],
+        mix_times=0,
+      )
+    )
+
+
+def test_mix_single_target_produces_matching_cycles():
+  lh = FakeLiquidHandler(channel_num=1)
+  target = DummyContainer("T_mix")
+
+  run(lh.mix(targets=[target], mix_time=2, mix_vol=5))
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  dispenses = [payload for name, payload in lh.calls if name == "dispense"]
+  assert len(aspirates) == len(dispenses) == 2
+  assert all(call["resources"] == [target] for call in aspirates)
+  assert all(call["vols"] == [5] for call in aspirates)
+  assert all(call["resources"] == [target] for call in dispenses)
+  assert all(call["vols"] == [5] for call in dispenses)
+
+
+def test_mix_multiple_targets_supports_per_target_offsets():
+  lh = FakeLiquidHandler(channel_num=1)
+  targets = [DummyContainer("T0"), DummyContainer("T1")]
+  offsets = ["left", "right"]
+  heights = [0.1, 0.2]
+  rates = [0.5, 1.0]
+
+  run(
+    lh.mix(
+      targets=targets,
+      mix_time=1,
+      mix_vol=3,
+      offsets=offsets,
+      height_to_bottom=heights,
+      mix_rate=rates,
+    )
+  )
+
+  aspirates = [payload for name, payload in lh.calls if name == "aspirate"]
+  assert len(aspirates) == 2
+  assert aspirates[0]["resources"] == [targets[0]]
+  assert aspirates[0]["offsets"] == [offsets[0]]
+  assert aspirates[0]["liquid_height"] == [heights[0]]
+  assert aspirates[0]["flow_rates"] == [rates[0]]
+  assert aspirates[1]["resources"] == [targets[1]]
+  assert aspirates[1]["offsets"] == [offsets[1]]
+  assert aspirates[1]["liquid_height"] == [heights[1]]
+  assert aspirates[1]["flow_rates"] == [rates[1]]
+
+

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.1"
+__version__ = "0.10.19"

unilabos/__main__.py

@@ -1,6 +0,0 @@
-"""Entry point for `python -m unilabos`."""
-
-from unilabos.app.main import main
-
-if __name__ == "__main__":
-    main()

unilabos/app/main.py

@@ -12,15 +12,6 @@ from typing import Dict, Any, List
 import networkx as nx
 import yaml
 
-# Windows 中文系统 stdout 默认 GBK，无法编码 banner / emoji 日志中的 Unicode 字符
-# 强制 stdout/stderr 用 UTF-8，避免 print 触发 UnicodeEncodeError 导致进程崩溃
-if sys.platform == "win32":
-    for _stream in (sys.stdout, sys.stderr):
-        try:
-            _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
-        except (AttributeError, OSError):
-            pass
-
 # 首先添加项目根目录到路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
 unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
@@ -242,7 +233,7 @@ def parse_args():
     parser.add_argument(
         "--addr",
         type=str,
-        default="https://leap-lab.bohrium.com/api/v1",
+        default="https://uni-lab.bohrium.com/api/v1",
         help="Laboratory backend address",
     )
     parser.add_argument(
@@ -447,10 +438,10 @@ def main():
     if args.addr != parser.get_default("addr"):
         if args.addr == "test":
             print_status("使用测试环境地址", "info")
-            HTTPConfig.remote_addr = "https://leap-lab.test.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
         elif args.addr == "uat":
             print_status("使用uat环境地址", "info")
-            HTTPConfig.remote_addr = "https://leap-lab.uat.bohrium.com/api/v1"
+            HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
         elif args.addr == "local":
             print_status("使用本地环境地址", "info")
             HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
@@ -562,7 +553,7 @@ def main():
         os._exit(0)
 
     if not BasicConfig.ak or not BasicConfig.sk:
-        print_status("后续运行必须拥有一个实验室，请前往 https://leap-lab.bohrium.com 注册实验室！", "warning")
+        print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
         os._exit(1)
     graph: nx.Graph
     resource_tree_set: ResourceTreeSet

unilabos/app/web/client.py

@@ -36,9 +36,6 @@ class HTTPClient:
             auth_secret = BasicConfig.auth_secret()
             self.auth = auth_secret
             info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
-        # 复用 TCP/TLS 连接，避免每次请求重新握手
-        self._session = requests.Session()
-        self._session.headers.update({"Authorization": f"Lab {self.auth}"})
         info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")
 
     def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
@@ -51,7 +48,7 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        response = self._session.post(
+        response = requests.post(
             f"{self.remote_addr}/edge/material/edge",
             json={
                 "edges": resources,
@@ -78,28 +75,25 @@ class HTTPClient:
         Returns:
             Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
         """
-        # dump() 只调用一次，复用给文件保存和 HTTP 请求
-        nodes_info = [x for xs in resources.dump() for x in xs]
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "w", encoding="utf-8") as f:
+            payload = {"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}
+            f.write(json.dumps(payload, indent=4))
+        # 从序列化数据中提取所有节点的UUID（保存旧UUID）
         old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
-        payload = {"nodes": nodes_info, "mount_uuid": mount_uuid}
-        body_bytes = _fast_dumps(payload)
-        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "wb") as f:
-            f.write(_fast_dumps_pretty(payload))
-        http_headers = {"Content-Type": "application/json"}
         if not self.initialized or first_add:
             self.initialized = True
             info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                 f"{self.remote_addr}/edge/material",
-                data=body_bytes,
-                headers=http_headers,
+                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
+                headers={"Authorization": f"Lab {self.auth}"},
                 timeout=60,
             )
         else:
-            response = self._session.put(
+            response = requests.put(
                 f"{self.remote_addr}/edge/material",
-                data=body_bytes,
-                headers=http_headers,
+                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
+                headers={"Authorization": f"Lab {self.auth}"},
                 timeout=10,
             )
 
@@ -117,7 +111,6 @@ class HTTPClient:
                     uuid_mapping[i["uuid"]] = i["cloud_uuid"]
         else:
             logger.error(f"添加物料失败: {response.text}")
-            logger.trace(f"添加物料失败: {nodes_info}")
         for u, n in old_uuids.items():
             if u in uuid_mapping:
                 n.res_content.uuid = uuid_mapping[u]
@@ -138,7 +131,7 @@ class HTTPClient:
         """
         with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_get.json"), "w", encoding="utf-8") as f:
             f.write(json.dumps({"uuids": uuid_list, "with_children": with_children}, indent=4))
-        response = self._session.post(
+        response = requests.post(
             f"{self.remote_addr}/edge/material/query",
             json={"uuids": uuid_list, "with_children": with_children},
             headers={"Authorization": f"Lab {self.auth}"},
@@ -152,7 +145,6 @@ class HTTPClient:
                 logger.error(f"查询物料失败: {response.text}")
             else:
                 data = res["data"]["nodes"]
-                logger.trace(f"resource_tree_get查询到物料: {data}")
                 return data
         else:
             logger.error(f"查询物料失败: {response.text}")
@@ -170,14 +162,14 @@ class HTTPClient:
         if not self.initialized:
             self.initialized = True
             info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                 f"{self.remote_addr}/lab/material",
                 json={"nodes": resources},
                 headers={"Authorization": f"Lab {self.auth}"},
                 timeout=100,
             )
         else:
-            response = self._session.put(
+            response = requests.put(
                 f"{self.remote_addr}/lab/material",
                 json={"nodes": resources},
                 headers={"Authorization": f"Lab {self.auth}"},
@@ -204,7 +196,7 @@ class HTTPClient:
         """
         with open(os.path.join(BasicConfig.working_dir, "req_resource_get.json"), "w", encoding="utf-8") as f:
             f.write(json.dumps({"id": id, "with_children": with_children}, indent=4))
-        response = self._session.get(
+        response = requests.get(
             f"{self.remote_addr}/lab/material",
             params={"id": id, "with_children": with_children},
             headers={"Authorization": f"Lab {self.auth}"},
@@ -245,14 +237,14 @@ class HTTPClient:
         if not self.initialized:
             self.initialized = True
             info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = self._session.post(
+            response = requests.post(
                 f"{self.remote_addr}/lab/material",
                 json={"nodes": resources},
                 headers={"Authorization": f"Lab {self.auth}"},
                 timeout=100,
             )
         else:
-            response = self._session.put(
+            response = requests.put(
                 f"{self.remote_addr}/lab/material",
                 json={"nodes": resources},
                 headers={"Authorization": f"Lab {self.auth}"},
@@ -282,7 +274,7 @@ class HTTPClient:
         with open(file_path, "rb") as file:
             files = {"files": file}
             logger.info(f"上传文件: {file_path} 到 {scene}")
-            response = self._session.post(
+            response = requests.post(
                 f"{self.remote_addr}/api/account/file_upload/{scene}",
                 files=files,
                 headers={"Authorization": f"Lab {self.auth}"},
@@ -322,7 +314,7 @@ class HTTPClient:
             "Content-Type": "application/json",
             "Content-Encoding": "gzip",
         }
-        response = self._session.post(
+        response = requests.post(
             f"{self.remote_addr}/lab/resource",
             data=compressed_body,
             headers=headers,
@@ -356,7 +348,7 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        response = self._session.get(
+        response = requests.get(
             f"{self.remote_addr}/edge/material/download",
             headers={"Authorization": f"Lab {self.auth}"},
             timeout=(3, 30),
@@ -417,7 +409,7 @@ class HTTPClient:
         with open(os.path.join(BasicConfig.working_dir, "req_workflow_upload.json"), "w", encoding="utf-8") as f:
             f.write(json.dumps(payload, indent=4, ensure_ascii=False))
 
-        response = self._session.post(
+        response = requests.post(
             f"{self.remote_addr}/lab/workflow/owner/import",
             json=payload,
             headers={"Authorization": f"Lab {self.auth}"},

unilabos/app/web/controller.py

@@ -58,14 +58,14 @@ class JobResultStore:
                 feedback=feedback or {},
                 timestamp=time.time(),
             )
-            logger.trace(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
+            logger.debug(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
 
     def get_and_remove(self, job_id: str) -> Optional[JobResult]:
         """获取并删除任务结果"""
         with self._results_lock:
             result = self._results.pop(job_id, None)
             if result:
-                logger.trace(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
+                logger.debug(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
             return result
 
     def get_result(self, job_id: str) -> Optional[JobResult]:

unilabos/app/ws_client.py

@@ -1113,7 +1113,7 @@ class MessageProcessor:
                 "task_id": task_id,
                 "job_id": job_id,
                 "free": free,
-                "need_more": need_more + 1,
+                "need_more": need_more,
             },
         }
 
@@ -1253,7 +1253,7 @@ class QueueProcessor:
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
                     "free": False,
-                    "need_more": 10 + 1,
+                    "need_more": 10,
                 },
             }
             self.message_processor.send_message(message)
@@ -1269,13 +1269,7 @@ class QueueProcessor:
         if not queued_jobs:
             return
 
-        queue_summary = {}
-        for j in queued_jobs:
-            key = f"{j.device_id}/{j.action_name}"
-            queue_summary[key] = queue_summary.get(key, 0) + 1
-        logger.debug(
-            f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs: {queue_summary}"
-        )
+        logger.debug(f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs")
 
         for job_info in queued_jobs:
             # 快照可能已过期：在遍历过程中 end_job() 可能已将此 job 移至 READY，
@@ -1292,7 +1286,7 @@ class QueueProcessor:
                     "task_id": job_info.task_id,
                     "job_id": job_info.job_id,
                     "free": False,
-                    "need_more": 10 + 1,
+                    "need_more": 10,
                 },
             }
             success = self.message_processor.send_message(message)

unilabos/config/config.py

@@ -46,7 +46,7 @@ class WSConfig:
 
 # HTTP配置
 class HTTPConfig:
-    remote_addr = "https://leap-lab.bohrium.com/api/v1"
+    remote_addr = "https://uni-lab.bohrium.com/api/v1"
 
 
 # ROS配置

unilabos/device_comms/opcua_client/node/uniopcua.py

@@ -43,7 +43,7 @@ class Base(ABC):
         self._type = typ
         self._data_type = data_type
         self._node: Optional[Node] = None
-
+        
     def _get_node(self) -> Node:
         if self._node is None:
             try:
@@ -66,7 +66,7 @@ class Base(ABC):
                 # 直接以字符串形式处理
                 if isinstance(nid, str):
                     nid = nid.strip()
-
+                    
                     # 处理包含类名的格式，如 'StringNodeId(ns=4;s=...)' 或 'NumericNodeId(ns=2;i=...)'
                     # 提取括号内的内容
                     match_wrapped = re.match(r'(String|Numeric|Byte|Guid|TwoByteNode|FourByteNode)NodeId\((.*)\)', nid)
@@ -116,16 +116,16 @@ class Base(ABC):
     def read(self) -> Tuple[Any, bool]:
         """读取节点值，返回(值, 是否出错)"""
         pass
-
+    
     @abstractmethod
     def write(self, value: Any) -> bool:
         """写入节点值，返回是否出错"""
         pass
-
+    
     @property
     def type(self) -> NodeType:
         return self._type
-
+    
     @property
     def node_id(self) -> str:
         return self._node_id
@@ -210,15 +210,15 @@ class Method(Base):
         super().__init__(client, name, node_id, NodeType.METHOD, data_type)
         self._parent_node_id = parent_node_id
         self._parent_node = None
-
+        
     def _get_parent_node(self) -> Node:
         if self._parent_node is None:
             try:
                 # 处理父节点ID，使用与_get_node相同的解析逻辑
                 import re
-
+                
                 nid = self._parent_node_id
-
+                
                 # 如果已经是 NodeId 对象，直接使用
                 try:
                     from opcua.ua import NodeId as UaNodeId
@@ -227,16 +227,16 @@ class Method(Base):
                         return self._parent_node
                 except Exception:
                     pass
-
+                
                 # 字符串处理
                 if isinstance(nid, str):
                     nid = nid.strip()
-
+                    
                     # 处理包含类名的格式
                     match_wrapped = re.match(r'(String|Numeric|Byte|Guid|TwoByteNode|FourByteNode)NodeId\((.*)\)', nid)
                     if match_wrapped:
                         nid = match_wrapped.group(2).strip()
-
+                    
                     # 常见短格式
                     if re.match(r'^ns=\d+;[is]=', nid):
                         self._parent_node = self._client.get_node(nid)
@@ -271,7 +271,7 @@ class Method(Base):
     def write(self, value: Any) -> bool:
         """方法节点不支持写入操作"""
         return True
-
+        
     def call(self, *args) -> Tuple[Any, bool]:
         """调用方法，返回(返回值, 是否出错)"""
         try:
@@ -285,7 +285,7 @@ class Method(Base):
 class Object(Base):
     def __init__(self, client: Client, name: str, node_id: str):
         super().__init__(client, name, node_id, NodeType.OBJECT, None)
-
+        
     def read(self) -> Tuple[Any, bool]:
         """对象节点不支持直接读取操作"""
         return None, True
@@ -293,7 +293,7 @@ class Object(Base):
     def write(self, value: Any) -> bool:
         """对象节点不支持直接写入操作"""
         return True
-
+    
     def get_children(self) -> Tuple[List[Node], bool]:
         """获取子节点列表，返回(子节点列表, 是否出错)"""
         try:
@@ -301,4 +301,4 @@ class Object(Base):
             return children, False
         except Exception as e:
             print(f"获取对象 {self._name} 的子节点失败: {e}")
-            return [], True
+            return [], True 

unilabos/device_mesh/resource_visalization.py

@@ -201,17 +201,42 @@ class ResourceVisualization:
                 self.moveit_controllers_yaml['moveit_simple_controller_manager'][f"{name}_{controller_name}"] = moveit_dict['moveit_simple_controller_manager'][controller_name]
 
 
+    @staticmethod
+    def _ensure_ros2_env() -> dict:
+        """确保 ROS2 环境变量正确设置，返回可用于子进程的 env dict"""
+        import sys
+        env = dict(os.environ)
+        conda_prefix = os.path.dirname(os.path.dirname(sys.executable))
+
+        if "AMENT_PREFIX_PATH" not in env or not env["AMENT_PREFIX_PATH"].strip():
+            candidate = os.pathsep.join([conda_prefix, os.path.join(conda_prefix, "Library")])
+            env["AMENT_PREFIX_PATH"] = candidate
+            os.environ["AMENT_PREFIX_PATH"] = candidate
+
+        extra_bin_dirs = [
+            os.path.join(conda_prefix, "Library", "bin"),
+            os.path.join(conda_prefix, "Library", "lib"),
+            os.path.join(conda_prefix, "Scripts"),
+            conda_prefix,
+        ]
+        current_path = env.get("PATH", "")
+        for d in extra_bin_dirs:
+            if d not in current_path:
+                current_path = d + os.pathsep + current_path
+        env["PATH"] = current_path
+        os.environ["PATH"] = current_path
+
+        return env
+
     def create_launch_description(self) -> LaunchDescription:
         """
         创建launch描述，包含robot_state_publisher和move_group节点
 
-        Args:
-            urdf_str: URDF文本
-
         Returns:
             LaunchDescription: launch描述对象
         """
-        # 检查ROS 2环境变量
+        launch_env = self._ensure_ros2_env()
+
         if "AMENT_PREFIX_PATH" not in os.environ:
             raise OSError(
                 "ROS 2环境未正确设置。需要设置 AMENT_PREFIX_PATH 环境变量。\n"
@@ -290,7 +315,7 @@ class ResourceVisualization:
                         {"robot_description": robot_description},
                         ros2_controllers,
                     ],
-                    env=dict(os.environ)
+                    env=launch_env,
                 )
             )
             for controller in self.moveit_controllers_yaml['moveit_simple_controller_manager']['controller_names']:
@@ -300,7 +325,7 @@ class ResourceVisualization:
                         executable="spawner",
                         arguments=[f"{controller}", "--controller-manager", f"controller_manager"],
                         output="screen",
-                        env=dict(os.environ)
+                        env=launch_env,
                     )
                 )
             controllers.append(
@@ -309,7 +334,7 @@ class ResourceVisualization:
                         executable="spawner",
                         arguments=["joint_state_broadcaster", "--controller-manager", f"controller_manager"],
                         output="screen",
-                        env=dict(os.environ)
+                        env=launch_env,
                 )
             )
             for i in controllers:
@@ -317,7 +342,6 @@ class ResourceVisualization:
         else:
             ros2_controllers = None
 
-        # 创建robot_state_publisher节点
         robot_state_publisher = nd(
             package='robot_state_publisher',
             executable='robot_state_publisher',
@@ -327,9 +351,8 @@ class ResourceVisualization:
                 'robot_description': robot_description,
                 'use_sim_time': False
             },
-            # kinematics_dict
             ],
-            env=dict(os.environ)
+            env=launch_env,
         )
 
 
@@ -361,7 +384,7 @@ class ResourceVisualization:
             executable='move_group',
             output='screen',
             parameters=moveit_params,
-            env=dict(os.environ)
+            env=launch_env,
         )
 
 
@@ -379,13 +402,11 @@ class ResourceVisualization:
                 arguments=['-d', f"{str(self.mesh_path)}/view_robot.rviz"],
                 output='screen',
                 parameters=[
-                    {'robot_description_kinematics': kinematics_dict,
-                     },
+                    {'robot_description_kinematics': kinematics_dict},
                     robot_description_planning,
                     planning_pipelines,
-
                 ],
-                env=dict(os.environ)
+                env=launch_env,
             )
             self.launch_description.add_action(rviz_node)
 

unilabos/devices/liquid_handling/laiyu/backend/__init__.py

@@ -1,7 +1,9 @@
 """
 LaiYu液体处理设备后端模块
+
+提供设备后端接口和实现
 """
 
-from .laiyu_v_backend import UniLiquidHandlerLaiyuBackend
+from .laiyu_backend import LaiYuLiquidBackend, create_laiyu_backend
 
-__all__ = ['UniLiquidHandlerLaiyuBackend']
+__all__ = ['LaiYuLiquidBackend', 'create_laiyu_backend']

unilabos/devices/liquid_handling/laiyu/backend/laiyu_backend.py

@@ -0,0 +1,334 @@
+"""
+LaiYu液体处理设备后端实现
+
+提供设备的后端接口和控制逻辑
+"""
+
+import logging
+from typing import Dict, Any, Optional, List
+from abc import ABC, abstractmethod
+
+# 尝试导入PyLabRobot后端
+try:
+    from pylabrobot.liquid_handling.backends import LiquidHandlerBackend
+    PYLABROBOT_AVAILABLE = True
+except ImportError:
+    PYLABROBOT_AVAILABLE = False
+    # 创建模拟后端基类
+    class LiquidHandlerBackend:
+        def __init__(self, name: str):
+            self.name = name
+            self.is_connected = False
+        
+        def connect(self):
+            """连接设备"""
+            pass
+        
+        def disconnect(self):
+            """断开连接"""
+            pass
+
+
+class LaiYuLiquidBackend(LiquidHandlerBackend):
+    """LaiYu液体处理设备后端"""
+    
+    def __init__(self, name: str = "LaiYu_Liquid_Backend"):
+        """
+        初始化LaiYu液体处理设备后端
+        
+        Args:
+            name: 后端名称
+        """
+        if PYLABROBOT_AVAILABLE:
+            # PyLabRobot 的 LiquidHandlerBackend 不接受参数
+            super().__init__()
+        else:
+            # 模拟版本接受 name 参数
+            super().__init__(name)
+        
+        self.name = name
+        self.logger = logging.getLogger(__name__)
+        self.is_connected = False
+        self.device_info = {
+            "name": "LaiYu液体处理设备",
+            "version": "1.0.0",
+            "manufacturer": "LaiYu",
+            "model": "LaiYu_Liquid_Handler"
+        }
+    
+    def connect(self) -> bool:
+        """
+        连接到LaiYu液体处理设备
+        
+        Returns:
+            bool: 连接是否成功
+        """
+        try:
+            self.logger.info("正在连接到LaiYu液体处理设备...")
+            # 这里应该实现实际的设备连接逻辑
+            # 目前返回模拟连接成功
+            self.is_connected = True
+            self.logger.info("成功连接到LaiYu液体处理设备")
+            return True
+        except Exception as e:
+            self.logger.error(f"连接LaiYu液体处理设备失败: {e}")
+            self.is_connected = False
+            return False
+    
+    def disconnect(self) -> bool:
+        """
+        断开与LaiYu液体处理设备的连接
+        
+        Returns:
+            bool: 断开连接是否成功
+        """
+        try:
+            self.logger.info("正在断开与LaiYu液体处理设备的连接...")
+            # 这里应该实现实际的设备断开连接逻辑
+            self.is_connected = False
+            self.logger.info("成功断开与LaiYu液体处理设备的连接")
+            return True
+        except Exception as e:
+            self.logger.error(f"断开LaiYu液体处理设备连接失败: {e}")
+            return False
+    
+    def is_device_connected(self) -> bool:
+        """
+        检查设备是否已连接
+        
+        Returns:
+            bool: 设备是否已连接
+        """
+        return self.is_connected
+    
+    def get_device_info(self) -> Dict[str, Any]:
+        """
+        获取设备信息
+        
+        Returns:
+            Dict[str, Any]: 设备信息字典
+        """
+        return self.device_info.copy()
+    
+    def home_device(self) -> bool:
+        """
+        设备归零操作
+        
+        Returns:
+            bool: 归零是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行归零操作")
+            return False
+        
+        try:
+            self.logger.info("正在执行设备归零操作...")
+            # 这里应该实现实际的设备归零逻辑
+            self.logger.info("设备归零操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"设备归零操作失败: {e}")
+            return False
+    
+    def aspirate(self, volume: float, location: Dict[str, Any]) -> bool:
+        """
+        吸液操作
+        
+        Args:
+            volume: 吸液体积 (微升)
+            location: 吸液位置信息
+            
+        Returns:
+            bool: 吸液是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行吸液操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行吸液操作: 体积={volume}μL, 位置={location}")
+            # 这里应该实现实际的吸液逻辑
+            self.logger.info("吸液操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"吸液操作失败: {e}")
+            return False
+    
+    def dispense(self, volume: float, location: Dict[str, Any]) -> bool:
+        """
+        排液操作
+        
+        Args:
+            volume: 排液体积 (微升)
+            location: 排液位置信息
+            
+        Returns:
+            bool: 排液是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行排液操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行排液操作: 体积={volume}μL, 位置={location}")
+            # 这里应该实现实际的排液逻辑
+            self.logger.info("排液操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"排液操作失败: {e}")
+            return False
+    
+    def pick_up_tip(self, location: Dict[str, Any]) -> bool:
+        """
+        取枪头操作
+        
+        Args:
+            location: 枪头位置信息
+            
+        Returns:
+            bool: 取枪头是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行取枪头操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行取枪头操作: 位置={location}")
+            # 这里应该实现实际的取枪头逻辑
+            self.logger.info("取枪头操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"取枪头操作失败: {e}")
+            return False
+    
+    def drop_tip(self, location: Dict[str, Any]) -> bool:
+        """
+        丢弃枪头操作
+        
+        Args:
+            location: 丢弃位置信息
+            
+        Returns:
+            bool: 丢弃枪头是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行丢弃枪头操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行丢弃枪头操作: 位置={location}")
+            # 这里应该实现实际的丢弃枪头逻辑
+            self.logger.info("丢弃枪头操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"丢弃枪头操作失败: {e}")
+            return False
+    
+    def move_to(self, location: Dict[str, Any]) -> bool:
+        """
+        移动到指定位置
+        
+        Args:
+            location: 目标位置信息
+            
+        Returns:
+            bool: 移动是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行移动操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在移动到位置: {location}")
+            # 这里应该实现实际的移动逻辑
+            self.logger.info("移动操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"移动操作失败: {e}")
+            return False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        获取设备状态
+        
+        Returns:
+            Dict[str, Any]: 设备状态信息
+        """
+        return {
+            "connected": self.is_connected,
+            "device_info": self.device_info,
+            "status": "ready" if self.is_connected else "disconnected"
+        }
+    
+    # PyLabRobot 抽象方法实现
+    def stop(self):
+        """停止所有操作"""
+        self.logger.info("停止所有操作")
+        pass
+    
+    @property
+    def num_channels(self) -> int:
+        """返回通道数量"""
+        return 1  # 单通道移液器
+    
+    def can_pick_up_tip(self, tip_rack, tip_position) -> bool:
+        """检查是否可以拾取吸头"""
+        return True  # 简化实现，总是返回True
+    
+    def pick_up_tips(self, tip_rack, tip_positions):
+        """拾取多个吸头"""
+        self.logger.info(f"拾取吸头: {tip_positions}")
+        pass
+    
+    def drop_tips(self, tip_rack, tip_positions):
+        """丢弃多个吸头"""
+        self.logger.info(f"丢弃吸头: {tip_positions}")
+        pass
+    
+    def pick_up_tips96(self, tip_rack):
+        """拾取96个吸头"""
+        self.logger.info("拾取96个吸头")
+        pass
+    
+    def drop_tips96(self, tip_rack):
+        """丢弃96个吸头"""
+        self.logger.info("丢弃96个吸头")
+        pass
+    
+    def aspirate96(self, volume, plate, well_positions):
+        """96通道吸液"""
+        self.logger.info(f"96通道吸液: 体积={volume}")
+        pass
+    
+    def dispense96(self, volume, plate, well_positions):
+        """96通道排液"""
+        self.logger.info(f"96通道排液: 体积={volume}")
+        pass
+    
+    def pick_up_resource(self, resource, location):
+        """拾取资源"""
+        self.logger.info(f"拾取资源: {resource}")
+        pass
+    
+    def drop_resource(self, resource, location):
+        """放置资源"""
+        self.logger.info(f"放置资源: {resource}")
+        pass
+    
+    def move_picked_up_resource(self, resource, location):
+        """移动已拾取的资源"""
+        self.logger.info(f"移动资源: {resource} 到 {location}")
+        pass
+
+
+def create_laiyu_backend(name: str = "LaiYu_Liquid_Backend") -> LaiYuLiquidBackend:
+    """
+    创建LaiYu液体处理设备后端实例
+    
+    Args:
+        name: 后端名称
+        
+    Returns:
+        LaiYuLiquidBackend: 后端实例
+    """
+    return LaiYuLiquidBackend(name)

unilabos/devices/liquid_handling/laiyu/backend/laiyu_v_backend.py

@@ -1,307 +1,385 @@
-"""LaiYu PLR 后端 — 对齐路径 B 硬件交互模式
-
-硬件初始化顺序与 laiyu_liquid_station.py (路径 B) 一致:
-  1. XYZController(auto_connect=True) — 先开串口
-  2. PipetteController.connect_shared() — 共享 XYZ 的串口 / 锁
-  3. home_all_axes() + pipette.initialize()
-"""
-
-import logging
+      
+import json
 from typing import List, Optional, Union
 
-from pylabrobot.liquid_handling.backends.backend import LiquidHandlerBackend
+from pylabrobot.liquid_handling.backends.backend import (
+  LiquidHandlerBackend,
+)
 from pylabrobot.liquid_handling.standard import (
-    Drop,
-    DropTipRack,
-    MultiHeadAspirationContainer,
-    MultiHeadAspirationPlate,
-    MultiHeadDispenseContainer,
-    MultiHeadDispensePlate,
-    Pickup,
-    PickupTipRack,
-    ResourceDrop,
-    ResourceMove,
-    ResourcePickup,
-    SingleChannelAspiration,
-    SingleChannelDispense,
+  Drop,
+  DropTipRack,
+  MultiHeadAspirationContainer,
+  MultiHeadAspirationPlate,
+  MultiHeadDispenseContainer,
+  MultiHeadDispensePlate,
+  Pickup,
+  PickupTipRack,
+  ResourceDrop,
+  ResourceMove,
+  ResourcePickup,
+  SingleChannelAspiration,
+  SingleChannelDispense,
 )
 from pylabrobot.resources import Resource, Tip
 
-from unilabos.devices.liquid_handling.laiyu.controllers.xyz_controller import XYZController
-from unilabos.devices.liquid_handling.laiyu.controllers.pipette_controller import (
-    PipetteController,
-    TipStatus,
-)
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+import time
+from rclpy.action import ActionClient
+from unilabos_msgs.action import SendCmd
+import re
 
-logger = logging.getLogger(__name__)
+from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
+from unilabos.devices.liquid_handling.laiyu.controllers.pipette_controller import PipetteController, TipStatus
 
 
 class UniLiquidHandlerLaiyuBackend(LiquidHandlerBackend):
-    """LaiYu 硬件后端 — PLR Backend 接口实现"""
+  """Chatter box backend for device-free testing. Prints out all operations."""
 
-    def __init__(
-        self,
-        num_channels: int = 1,
-        tip_length: float = 0,
-        total_height: float = 310,
-        port: str = "/dev/ttyUSB0",
-        baudrate: int = 115200,
-        pipette_address: int = 4,
-    ):
-        super().__init__()
-        self._num_channels = num_channels
-        self.tip_length = tip_length
-        self.total_height = total_height
+  _pip_length = 5
+  _vol_length = 8
+  _resource_length = 20
+  _offset_length = 16
+  _flow_rate_length = 10
+  _blowout_length = 10
+  _lld_z_length = 10
+  _kwargs_length = 15
+  _tip_type_length = 12
+  _max_volume_length = 16
+  _fitting_depth_length = 20
+  _tip_length_length = 16
+  # _pickup_method_length = 20
+  _filter_length = 10
 
-        # 保存配置，延迟到 setup() 再创建硬件对象
-        self._port = port
-        self._baudrate = baudrate
-        self._pipette_address = pipette_address
+  def __init__(self, num_channels: int = 8 , tip_length: float = 0 , total_height: float = 310, port: str = "/dev/ttyUSB0"):
+    """Initialize a chatter box backend."""
+    super().__init__()
+    self._num_channels = num_channels
+    self.tip_length = tip_length
+    self.total_height = total_height
+# rclpy.init()
+    if not rclpy.ok():
+        rclpy.init()
+    self.joint_state_publisher = None
+    self.hardware_interface = PipetteController(port=port)
 
-        self._xyz: Optional[XYZController] = None
-        self._pipette_ctrl: Optional[PipetteController] = None
-        self._ros_node = None
+  async def setup(self):
+    # self.joint_state_publisher = JointStatePublisher()
+    # self.hardware_interface.xyz_controller.connect_device()
+    # self.hardware_interface.xyz_controller.home_all_axes()
+    await super().setup()
+    self.hardware_interface.connect()
+    self.hardware_interface.initialize()
 
-    # ------------------------------------------------------------------ lifecycle
+    print("Setting up the liquid handler.")
 
-    def post_init(self, ros_node):
-        """接收 ROS 节点引用（由 Handler.post_init 调用）"""
-        self._ros_node = ros_node
+  async def stop(self):
+    print("Stopping the liquid handler.")
 
-    async def setup(self):
-        """按路径 B 顺序初始化硬件"""
-        await super().setup()
+  def serialize(self) -> dict:
+    return {**super().serialize(), "num_channels": self.num_channels}
 
-        # 1. XYZ 先开串口
-        self._xyz = XYZController(
-            port=self._port,
-            baudrate=self._baudrate,
-            auto_connect=True,
-        )
-        if not self._xyz.is_connected:
-            raise RuntimeError("XYZ 控制器连接失败")
+  def pipette_aspirate(self, volume: float, flow_rate: float):
 
-        # 2. PipetteController 共享 XYZ 串口
-        self._pipette_ctrl = PipetteController(
-            port=self._port,
-            address=self._pipette_address,
-        )
-        self._pipette_ctrl.connect_shared(
-            serial_conn=self._xyz.serial_conn,
-            serial_lock=self._xyz.serial_lock,
-            xyz_controller=self._xyz,
-        )
+    self.hardware_interface.pipette.set_max_speed(flow_rate)
+    res = self.hardware_interface.pipette.aspirate(volume=volume)
+    
+    if not res:
+        self.hardware_interface.logger.error("吸取失败，当前体积: {self.hardware_interface.current_volume}")
+        return
 
-        # 3. 回零 + 移液器初始化
-        self._xyz.home_all_axes()
-        self._pipette_ctrl.initialize()
+    self.hardware_interface.current_volume += volume 
 
-        logger.info("LaiYu 后端硬件初始化完成")
+  def pipette_dispense(self, volume: float, flow_rate: float):
 
-    async def stop(self):
-        """正确断开硬件"""
-        try:
-            if self._pipette_ctrl:
-                self._pipette_ctrl.disconnect_shared()
-            if self._xyz:
-                self._xyz.disconnect()
-            logger.info("LaiYu 后端硬件已断开")
-        except Exception as e:
-            logger.error(f"停止后端失败: {e}")
+    self.hardware_interface.pipette.set_max_speed(flow_rate)
+    res = self.hardware_interface.pipette.dispense(volume=volume)
+    if not res:
+        self.hardware_interface.logger.error("排液失败，当前体积: {self.hardware_interface.current_volume}")
+        return
+    self.hardware_interface.current_volume -= volume
 
-    # ------------------------------------------------------------------ helpers
+  @property
+  def num_channels(self) -> int:
+    return self._num_channels
 
-    def _plr_to_machine_coords(self, resource, offset):
-        """PLR Resource 坐标 → 机器坐标 (倒置龙门架: total_height - z, -y)"""
-        coordinate = resource.get_absolute_location(x="c", y="c")
-        x = coordinate.x + offset.x
-        y = coordinate.y + offset.y
-        z_plr = coordinate.z + offset.z
-        return x, -y, self.total_height - (z_plr + self.tip_length)
+  async def assigned_resource_callback(self, resource: Resource):
+    print(f"Resource {resource.name} was assigned to the liquid handler.")
 
-    def _pipette_aspirate(self, volume: float, flow_rate: float):
-        self._pipette_ctrl.pipette.set_max_speed(flow_rate)
-        res = self._pipette_ctrl.pipette.aspirate(volume=volume)
-        if not res:
-            logger.error(f"吸取失败，当前体积: {self._pipette_ctrl.current_volume}")
-            return
-        self._pipette_ctrl.current_volume += volume
+  async def unassigned_resource_callback(self, name: str):
+    print(f"Resource {name} was unassigned from the liquid handler.")
 
-    def _pipette_dispense(self, volume: float, flow_rate: float):
-        self._pipette_ctrl.pipette.set_max_speed(flow_rate)
-        res = self._pipette_ctrl.pipette.dispense(volume=volume)
-        if not res:
-            logger.error(f"排液失败，当前体积: {self._pipette_ctrl.current_volume}")
-            return
-        self._pipette_ctrl.current_volume -= volume
+  async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int], **backend_kwargs):
+    print("Picking up tips:")
+    # print(ops.tip)
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'tip type':<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+      f"{'max volume (µL)':<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+      f"{'fitting depth (mm)':<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+      f"{'tip length (mm)':<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
+      f"{'filter':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+    )
+    # print(header)
 
-    # ------------------------------------------------------------------ properties
+    for op, channel in zip(ops, use_channels):
+      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
+      row = (
+        f"  p{channel}: "
+        f"{op.resource.name[-30:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{op.tip.__class__.__name__:<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+        f"{op.tip.maximal_volume:<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+        f"{op.tip.fitting_depth:<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+        f"{op.tip.total_tip_length:<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
+        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+      )
+      # print(row)
+      # print(op.resource.get_absolute_location())
+    
+    self.tip_length = ops[0].tip.total_tip_length
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print("moving")
+    self.hardware_interface._update_tip_status()
+    if self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("已有枪头，无需重复拾取")
+        return
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z,speed=200)
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height,speed=100)
+    # self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "pick",channels=use_channels)
+    #   goback()
 
-    def serialize(self) -> dict:
-        return {**super().serialize(), "num_channels": self.num_channels}
 
-    @property
-    def num_channels(self) -> int:
-        return self._num_channels
 
-    # ------------------------------------------------------------------ resource callbacks
 
-    async def assigned_resource_callback(self, resource: Resource):
-        logger.info(f"Resource {resource.name} was assigned to the liquid handler.")
+  async def drop_tips(self, ops: List[Drop], use_channels: List[int], **backend_kwargs):
+    print("Dropping tips:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'tip type':<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+      f"{'max volume (µL)':<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+      f"{'fitting depth (mm)':<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+      f"{'tip length (mm)':<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
+      f"{'filter':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+    )
+    # print(header)
 
-    async def unassigned_resource_callback(self, name: str):
-        logger.info(f"Resource {name} was unassigned from the liquid handler.")
+    for op, channel in zip(ops, use_channels):
+      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
+      row = (
+        f"  p{channel}: "
+        f"{op.resource.name[-30:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{op.tip.__class__.__name__:<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+        f"{op.tip.maximal_volume:<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+        f"{op.tip.fitting_depth:<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+        f"{op.tip.total_tip_length:<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
+        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+      )
+      # print(row)
 
-    # ------------------------------------------------------------------ pick_up_tips
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z -20
+    # print(x, y, z)
+    # print("moving")
+    self.hardware_interface._update_tip_status()
+    if self.hardware_interface.tip_status == TipStatus.NO_TIP:
+        print("无枪头，无需丢弃")
+        return
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z,speed=200)
+    self.hardware_interface.eject_tip
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)  
 
-    async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int], **backend_kwargs):
-        tip = ops[0].tip
-        self.tip_length = tip.total_tip_length
-        x, y, z_top = self._plr_to_machine_coords(ops[0].resource, ops[0].offset)
+  async def aspirate(
+    self,
+    ops: List[SingleChannelAspiration],
+    use_channels: List[int],
+    **backend_kwargs,
+  ):
+    print("Aspirating:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'vol(ul)':<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'flow rate':<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+      f"{'blowout':<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+      f"{'lld_z':<{UniLiquidHandlerLaiyuBackend._lld_z_length}}  "
+      # f"{'liquids':<20}" # TODO: add liquids
+    )
+    for key in backend_kwargs:
+      header += f"{key:<{UniLiquidHandlerLaiyuBackend._kwargs_length}} "[-16:]
+    # print(header)
 
-        self._pipette_ctrl._update_tip_status()
-        if self._pipette_ctrl.tip_status == TipStatus.TIP_ATTACHED:
-            logger.warning("已有枪头，无需重复拾取")
-            return
+    for o, p in zip(ops, use_channels):
+      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
+      row = (
+        f"  p{p}: "
+        f"{o.volume:<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+        f"{o.resource.name[-20:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{str(o.flow_rate):<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+        f"{str(o.liquid_height):<{UniLiquidHandlerLaiyuBackend._lld_z_length}} "
+        # f"{o.liquids if o.liquids is not None else 'none'}"
+      )
+      for key, value in backend_kwargs.items():
+        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
+          value = "".join("T" if v else "F" for v in value)
+        if isinstance(value, list):
+          value = "".join(map(str, value))
+        row += f" {value:<15}"
+      # print(row)
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print(x, y, z)
+    # print("moving")
 
-        try:
-            # 1. 移到枪头正上方
-            self._xyz.move_to_work_coord_safe(x=x, y=y, z=z_top, speed=200)
-            # 2. 下压到套枪头深度（fitting_depth 是枪头套入长度）
-            z_pickup = z_top + tip.fitting_depth
-            self._xyz.move_to_work_coord_safe(z=z_pickup, speed=100)
-            # 3. 退回安全高度
-            self._xyz.move_to_work_coord_safe(
-                z=self._xyz.machine_config.safe_z_height, speed=100
-            )
-        except Exception as e:
-            logger.error(f"pick_up_tips 移动失败: {e}")
-            raise
+    # 判断枪头是否存在
+    self.hardware_interface._update_tip_status()
+    if not self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("无枪头，无法吸液")
+        return
+    # 判断吸液量是否超过枪头容量
+    flow_rate = backend_kwargs["flow_rate"] if "flow_rate" in backend_kwargs else 500
+    blow_out_air_volume = backend_kwargs["blow_out_air_volume"] if "blow_out_air_volume" in backend_kwargs else 0
+    if self.hardware_interface.current_volume + ops[0].volume + blow_out_air_volume > self.hardware_interface.max_volume:
+        self.hardware_interface.logger.error(f"吸液量超过枪头容量: {self.hardware_interface.current_volume + ops[0].volume} > {self.hardware_interface.max_volume}")
+        return
 
-    # ------------------------------------------------------------------ drop_tips
+    # 移动到吸液位置
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z,speed=200)
+    self.pipette_aspirate(volume=ops[0].volume, flow_rate=flow_rate)
 
-    async def drop_tips(self, ops: List[Drop], use_channels: List[int], **backend_kwargs):
-        x, y, z = self._plr_to_machine_coords(ops[0].resource, ops[0].offset)
-        z -= 20  # 额外下移补偿
 
-        self._pipette_ctrl._update_tip_status()
-        if self._pipette_ctrl.tip_status == TipStatus.NO_TIP:
-            logger.warning("无枪头，无需丢弃")
-            return
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)
+    if blow_out_air_volume >0: 
+        self.pipette_aspirate(volume=blow_out_air_volume, flow_rate=flow_rate)
 
-        try:
-            self._xyz.move_to_work_coord_safe(x=x, y=y, z=z, speed=200)
-            self._pipette_ctrl.eject_tip()  # 修复: 原来缺少 ()
-            self._xyz.move_to_work_coord_safe(
-                z=self._xyz.machine_config.safe_z_height
-            )
-        except Exception as e:
-            logger.error(f"drop_tips 失败: {e}")
-            raise
 
-    # ------------------------------------------------------------------ aspirate
 
-    async def aspirate(
-        self,
-        ops: List[SingleChannelAspiration],
-        use_channels: List[int],
-        **backend_kwargs,
-    ):
-        x, y, z = self._plr_to_machine_coords(ops[0].resource, ops[0].offset)
 
-        self._pipette_ctrl._update_tip_status()
-        if self._pipette_ctrl.tip_status != TipStatus.TIP_ATTACHED:
-            raise RuntimeError("无枪头，无法吸液")
+  async def dispense(
+    self,
+    ops: List[SingleChannelDispense],
+    use_channels: List[int],
+    **backend_kwargs,
+  ):
+    # print("Dispensing:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'vol(ul)':<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'flow rate':<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+      f"{'blowout':<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+      f"{'lld_z':<{UniLiquidHandlerLaiyuBackend._lld_z_length}}  "
+      # f"{'liquids':<20}" # TODO: add liquids
+    )
+    for key in backend_kwargs:
+      header += f"{key:<{UniLiquidHandlerLaiyuBackend._kwargs_length}} "[-16:]
+    # print(header)
 
-        flow_rate = backend_kwargs.get("flow_rate", 500)
-        blow_out_air_volume = backend_kwargs.get("blow_out_air_volume", 0)
+    for o, p in zip(ops, use_channels):
+      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
+      row = (
+        f"  p{p}: "
+        f"{o.volume:<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+        f"{o.resource.name[-20:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{str(o.flow_rate):<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+        f"{str(o.liquid_height):<{UniLiquidHandlerLaiyuBackend._lld_z_length}} "
+        # f"{o.liquids if o.liquids is not None else 'none'}"
+      )
+      for key, value in backend_kwargs.items():
+        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
+          value = "".join("T" if v else "F" for v in value)
+        if isinstance(value, list):
+          value = "".join(map(str, value))
+        row += f" {value:<{UniLiquidHandlerLaiyuBackend._kwargs_length}}"
+      # print(row)
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print(x, y, z)
+    # print("moving")
 
-        if (
-            self._pipette_ctrl.current_volume + ops[0].volume + blow_out_air_volume
-            > self._pipette_ctrl.max_volume
-        ):
-            raise RuntimeError(
-                f"吸液量超过枪头容量: "
-                f"{self._pipette_ctrl.current_volume + ops[0].volume} > {self._pipette_ctrl.max_volume}"
-            )
+    # 判断枪头是否存在
+    self.hardware_interface._update_tip_status()
+    if not self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("无枪头，无法排液")
+        return
+    # 判断排液量是否超过枪头容量
+    flow_rate = backend_kwargs["flow_rate"] if "flow_rate" in backend_kwargs else 500
+    blow_out_air_volume = backend_kwargs["blow_out_air_volume"] if "blow_out_air_volume" in backend_kwargs else 0
+    if self.hardware_interface.current_volume - ops[0].volume - blow_out_air_volume < 0:
+        self.hardware_interface.logger.error(f"排液量超过枪头容量: {self.hardware_interface.current_volume - ops[0].volume - blow_out_air_volume} < 0")
+        return
 
-        self._xyz.move_to_work_coord_safe(x=x, y=y, z=z, speed=200)
-        self._pipette_aspirate(volume=ops[0].volume, flow_rate=flow_rate)
+    
+    # 移动到排液位置  
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z,speed=200)
+    self.pipette_dispense(volume=ops[0].volume, flow_rate=flow_rate)
 
-        self._xyz.move_to_work_coord_safe(
-            z=self._xyz.machine_config.safe_z_height
-        )
-        if blow_out_air_volume > 0:
-            self._pipette_aspirate(volume=blow_out_air_volume, flow_rate=flow_rate)
 
-    # ------------------------------------------------------------------ dispense
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)
+    if blow_out_air_volume > 0: 
+        self.pipette_dispense(volume=blow_out_air_volume, flow_rate=flow_rate)
+    # self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
 
-    async def dispense(
-        self,
-        ops: List[SingleChannelDispense],
-        use_channels: List[int],
-        **backend_kwargs,
-    ):
-        x, y, z = self._plr_to_machine_coords(ops[0].resource, ops[0].offset)
+  async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
+    print(f"Picking up tips from {pickup.resource.name}.")
 
-        self._pipette_ctrl._update_tip_status()
-        if self._pipette_ctrl.tip_status != TipStatus.TIP_ATTACHED:
-            raise RuntimeError("无枪头，无法排液")
+  async def drop_tips96(self, drop: DropTipRack, **backend_kwargs):
+    print(f"Dropping tips to {drop.resource.name}.")
 
-        flow_rate = backend_kwargs.get("flow_rate", 500)
-        blow_out_air_volume = backend_kwargs.get("blow_out_air_volume", 0)
+  async def aspirate96(
+    self, aspiration: Union[MultiHeadAspirationPlate, MultiHeadAspirationContainer]
+  ):
+    if isinstance(aspiration, MultiHeadAspirationPlate):
+      resource = aspiration.wells[0].parent
+    else:
+      resource = aspiration.container
+    print(f"Aspirating {aspiration.volume} from {resource}.")
 
-        if (
-            self._pipette_ctrl.current_volume - ops[0].volume - blow_out_air_volume < 0
-        ):
-            raise RuntimeError(
-                f"排液量超过当前体积: "
-                f"{self._pipette_ctrl.current_volume - ops[0].volume - blow_out_air_volume} < 0"
-            )
+  async def dispense96(self, dispense: Union[MultiHeadDispensePlate, MultiHeadDispenseContainer]):
+    if isinstance(dispense, MultiHeadDispensePlate):
+      resource = dispense.wells[0].parent
+    else:
+      resource = dispense.container
+    print(f"Dispensing {dispense.volume} to {resource}.")
 
-        self._xyz.move_to_work_coord_safe(x=x, y=y, z=z, speed=200)
-        self._pipette_dispense(volume=ops[0].volume, flow_rate=flow_rate)
+  async def pick_up_resource(self, pickup: ResourcePickup):
+    print(f"Picking up resource: {pickup}")
 
-        self._xyz.move_to_work_coord_safe(
-            z=self._xyz.machine_config.safe_z_height
-        )
-        if blow_out_air_volume > 0:
-            self._pipette_dispense(volume=blow_out_air_volume, flow_rate=flow_rate)
+  async def move_picked_up_resource(self, move: ResourceMove):
+    print(f"Moving picked up resource: {move}")
 
-    # ------------------------------------------------------------------ 96-channel stubs
+  async def drop_resource(self, drop: ResourceDrop):
+    print(f"Dropping resource: {drop}")
 
-    async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
-        logger.info(f"Picking up tips from {pickup.resource.name}.")
-
-    async def drop_tips96(self, drop: DropTipRack, **backend_kwargs):
-        logger.info(f"Dropping tips to {drop.resource.name}.")
-
-    async def aspirate96(
-        self, aspiration: Union[MultiHeadAspirationPlate, MultiHeadAspirationContainer]
-    ):
-        if isinstance(aspiration, MultiHeadAspirationPlate):
-            resource = aspiration.wells[0].parent
-        else:
-            resource = aspiration.container
-        logger.info(f"Aspirating {aspiration.volume} from {resource}.")
-
-    async def dispense96(
-        self, dispense: Union[MultiHeadDispensePlate, MultiHeadDispenseContainer]
-    ):
-        if isinstance(dispense, MultiHeadDispensePlate):
-            resource = dispense.wells[0].parent
-        else:
-            resource = dispense.container
-        logger.info(f"Dispensing {dispense.volume} to {resource}.")
-
-    async def pick_up_resource(self, pickup: ResourcePickup):
-        logger.info(f"Picking up resource: {pickup}")
-
-    async def move_picked_up_resource(self, move: ResourceMove):
-        logger.info(f"Moving picked up resource: {move}")
-
-    async def drop_resource(self, drop: ResourceDrop):
-        logger.info(f"Dropping resource: {drop}")
-
-    def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
-        return True
+  def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
+    return True
+    

unilabos/devices/liquid_handling/laiyu/controllers/pipette_controller.py

@@ -5,16 +5,21 @@
 封装SOPA移液器的高级控制功能
 """
 
+# 添加项目根目录到Python路径以解决模块导入问题
 import sys
 import os
-
-_current_file = os.path.abspath(__file__)
-_project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(_current_file)))))
-if _project_root not in sys.path:
-    sys.path.insert(0, _project_root)
+from tkinter import N
 
 from unilabos.devices.liquid_handling.laiyu.drivers.xyz_stepper_driver import ModbusException
 
+# 无论如何都添加项目根目录到路径
+current_file = os.path.abspath(__file__)
+# 从 .../Uni-Lab-OS/unilabos/devices/LaiYu_Liquid/controllers/pipette_controller.py
+# 向上5级到 .../Uni-Lab-OS
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(current_file)))))
+# 强制添加项目根目录到sys.path的开头
+sys.path.insert(0, project_root)
+
 import time
 import logging
 from typing import Optional, List, Dict, Tuple
@@ -148,7 +153,7 @@ class PipetteController:
                 logger.error("移液器连接失败")
                 return False
             logger.info("移液器连接成功")
-
+            
             # 连接XYZ步进电机控制器（如果提供了端口）
             if self.xyz_port != self.pipette_port:
                 try:
@@ -167,62 +172,24 @@ class PipetteController:
                 try:
                     self.xyz_controller = XYZController(self.xyz_port, auto_connect=False)
                     self.xyz_controller.serial_conn = self.pipette.serial_port
-                    self.xyz_controller.serial_lock = self.pipette.lock
                     self.xyz_controller.is_connected = True
-                    logger.info("XYZ控制器与移液器共享串口和互斥锁")
                 except Exception as e:
-                    logger.warning(f"共享端口 XYZ 控制器创建失败: {e}")
-                    self.xyz_controller = None
-                    self.xyz_connected = False
-
+                    logger.info("未配置XYZ步进电机端口，跳过运动控制器连接")
+            
             return True
         except Exception as e:
             logger.error(f"设备连接失败: {e}")
             return False
 
-    def connect_shared(self, serial_conn, serial_lock, xyz_controller: XYZController) -> bool:
-        """使用已连接的串口和XYZ控制器（路径 B 模式：XYZ 先开串口，移液器共享）
-
-        Args:
-            serial_conn: 已打开的串口连接（来自 XYZController）
-            serial_lock: 串口互斥锁（来自 XYZController）
-            xyz_controller: 已连接的 XYZController 实例
-        """
-        try:
-            self.pipette.serial_port = serial_conn
-            self.pipette.lock = serial_lock
-            self.pipette.is_connected = True
-
-            self.xyz_controller = xyz_controller
-            self.xyz_connected = True
-
-            logger.info("移液控制器已通过 connect_shared 共享 XYZ 串口")
-            return True
-        except Exception as e:
-            logger.error(f"connect_shared 失败: {e}")
-            return False
-
-    def disconnect_shared(self) -> None:
-        """释放共享串口引用（与 connect_shared 对称）。
-
-        注意：不关闭串口本身，串口由 XYZController 负责关闭。
-        """
-        try:
-            self.pipette.serial_port = None
-            self.pipette.lock = None
-            self.pipette.is_connected = False
-            self.xyz_controller = None
-            self.xyz_connected = False
-            logger.info("移液控制器已释放共享串口引用")
-        except Exception as e:
-            logger.error(f"disconnect_shared 失败: {e}")
-
     def initialize(self) -> bool:
         """初始化移液器"""
         try:
             if self.pipette.initialize():
                 logger.info("移液器初始化成功")
+                # 检查枪头状态
                 self._update_tip_status()
+                self.xyz_controller.home_all_axes()
+                self.xyz_controller.move_to_work_coord_safe(x=0, y=-150, z=0)
                 return True
             return False
         except Exception as e:
@@ -231,58 +198,56 @@ class PipetteController:
 
     def disconnect(self):
         """断开连接"""
-        if self.xyz_controller and self.xyz_connected:
-            if self.xyz_port != self.pipette_port:
-                try:
-                    self.xyz_controller.disconnect()
-                    logger.info("XYZ 步进电机已断开")
-                except Exception as e:
-                    logger.error(f"断开 XYZ 步进电机失败: {e}")
-            else:
-                self.xyz_controller.serial_conn = None
-            self.xyz_connected = False
-            self.xyz_controller = None
-
+        # 断开移液器连接
         self.pipette.disconnect()
         logger.info("移液器已断开")
+        
+        # 断开 XYZ 步进电机连接
+        if self.xyz_controller and self.xyz_connected:
+            try:
+                self.xyz_controller.disconnect()
+                self.xyz_connected = False
+                logger.info("XYZ 步进电机已断开")
+            except Exception as e:
+                logger.error(f"断开 XYZ 步进电机失败: {e}")
 
     def _check_xyz_safety(self, axis: MotorAxis, target_position: int) -> bool:
         """
         检查 XYZ 轴移动的安全性
-
+        
         Args:
             axis: 电机轴
             target_position: 目标位置(步数)
-
+            
         Returns:
             是否安全
         """
         try:
             # 获取当前电机状态
             motor_position = self.xyz_controller.get_motor_status(axis)
-
+            
             # 检查电机状态是否正常 (不是碰撞停止或限位停止)
-            if motor_position.status in [MotorStatus.COLLISION_STOP,
-                                       MotorStatus.FORWARD_LIMIT_STOP,
+            if motor_position.status in [MotorStatus.COLLISION_STOP, 
+                                       MotorStatus.FORWARD_LIMIT_STOP, 
                                        MotorStatus.REVERSE_LIMIT_STOP]:
                 logger.error(f"{axis.name} 轴电机处于错误状态: {motor_position.status.name}")
                 return False
-
+                
             # 检查位置限制 (扩大安全范围以适应实际硬件)
             # 步进电机的位置范围通常很大，这里设置更合理的范围
             if target_position < -500000 or target_position > 500000:
                 logger.error(f"{axis.name} 轴目标位置超出安全范围: {target_position}")
                 return False
-
+                
             # 检查移动距离是否过大 (单次移动不超过 20000 步，约12mm)
             current_position = motor_position.steps
             move_distance = abs(target_position - current_position)
             if move_distance > 20000:
                 logger.error(f"{axis.name} 轴单次移动距离过大: {move_distance}步")
                 return False
-
+                
             return True
-
+            
         except Exception as e:
             logger.error(f"安全检查失败: {e}")
             return False
@@ -290,48 +255,48 @@ class PipetteController:
     def move_z_relative(self, distance_mm: float, speed: int = 2000, acceleration: int = 500) -> bool:
         """
         Z轴相对移动
-
+        
         Args:
             distance_mm: 移动距离(mm)，正值向下，负值向上
             speed: 移动速度(rpm)
             acceleration: 加速度(rpm/s)
-
+            
         Returns:
             移动是否成功
         """
         if not self.xyz_controller or not self.xyz_connected:
             logger.error("XYZ 步进电机未连接，无法执行移动")
             return False
-
+            
         try:
             # 参数验证
             if abs(distance_mm) > 15.0:
                 logger.error(f"移动距离过大: {distance_mm}mm，最大允许15mm")
                 return False
-
+                
             if speed < 100 or speed > 5000:
                 logger.error(f"速度参数无效: {speed}rpm，范围应为100-5000")
                 return False
-
+                
             # 获取当前 Z 轴位置
             current_status = self.xyz_controller.get_motor_status(MotorAxis.Z)
             current_z_position = current_status.steps
-
+            
             # 计算移动距离对应的步数 (1mm = 1638.4步)
             mm_to_steps = 1638.4
             move_distance_steps = int(distance_mm * mm_to_steps)
-
+            
             # 计算目标位置
             target_z_position = current_z_position + move_distance_steps
-
+            
             # 安全检查
             if not self._check_xyz_safety(MotorAxis.Z, target_z_position):
                 logger.error("Z轴移动安全检查失败")
                 return False
-
+            
             logger.info(f"Z轴相对移动: {distance_mm}mm ({move_distance_steps}步)")
             logger.info(f"当前位置: {current_z_position}步 -> 目标位置: {target_z_position}步")
-
+            
             # 执行移动
             success = self.xyz_controller.move_to_position(
                 axis=MotorAxis.Z,
@@ -340,28 +305,28 @@ class PipetteController:
                 acceleration=acceleration,
                 precision=50
             )
-
+            
             if not success:
                 logger.error("Z轴移动命令发送失败")
                 return False
-
+                
             # 等待移动完成
             if not self.xyz_controller.wait_for_completion(MotorAxis.Z, timeout=10.0):
                 logger.error("Z轴移动超时")
                 return False
-
+                
             # 验证移动结果
             final_status = self.xyz_controller.get_motor_status(MotorAxis.Z)
             final_position = final_status.steps
             position_error = abs(final_position - target_z_position)
-
+            
             logger.info(f"Z轴移动完成，最终位置: {final_position}步，误差: {position_error}步")
-
+            
             if position_error > 100:
                 logger.warning(f"Z轴位置误差较大: {position_error}步")
-
+                
             return True
-
+            
         except ModbusException as e:
             logger.error(f"Modbus通信错误: {e}")
             return False
@@ -372,20 +337,21 @@ class PipetteController:
     def emergency_stop(self) -> bool:
         """
         紧急停止所有运动
-
+        
         Returns:
             停止是否成功
         """
         success = True
-
+        
+        # 停止移液器操作
         try:
-            if self.pipette and self.pipette.is_connected:
-                self.pipette.emergency_stop()
+            if self.pipette and self.connected:
+                # 这里可以添加移液器的紧急停止逻辑
                 logger.info("移液器紧急停止")
         except Exception as e:
             logger.error(f"移液器紧急停止失败: {e}")
             success = False
-
+            
         # 停止 XYZ 轴运动
         try:
             if self.xyz_controller and self.xyz_connected:
@@ -394,7 +360,7 @@ class PipetteController:
         except Exception as e:
             logger.error(f"XYZ 轴紧急停止失败: {e}")
             success = False
-
+            
         return success
 
     def pickup_tip(self) -> bool:
@@ -410,7 +376,7 @@ class PipetteController:
             return True
 
         logger.info("开始装载枪头 - Z轴向下移动10mm")
-
+        
         # 使用相对移动方法，向下移动10mm
         if self.move_z_relative(distance_mm=10.0, speed=2000, acceleration=500):
             # 更新枪头状态
@@ -722,31 +688,31 @@ class PipetteController:
 if __name__ == "__main__":
     # 配置日志
     import logging
-
+    
     # 设置日志级别
     logging.basicConfig(
         level=logging.INFO,
         format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
     )
-
+    
     def interactive_test():
         """交互式测试模式 - 适用于已连接的设备"""
         print("\n" + "=" * 60)
         print("🧪 移液器交互式测试模式")
         print("=" * 60)
-
+        
         # 获取用户输入的连接参数
         print("\n📡 设备连接配置:")
         port = input("请输入移液器串口端口 (默认: /dev/ttyUSB_CH340): ").strip() or "/dev/ttyUSB_CH340"
         address_input = input("请输入移液器设备地址 (默认: 4): ").strip()
         address = int(address_input) if address_input else 4
-
+        
         # 询问是否连接 XYZ 步进电机控制器
         xyz_enable = input("是否连接 XYZ 步进电机控制器? (y/N): ").strip().lower()
         xyz_port = None
         if xyz_enable not in ['n', 'no']:
             xyz_port = input("请输入 XYZ 控制器串口端口 (默认: /dev/ttyUSB_CH340): ").strip() or "/dev/ttyUSB_CH340"
-
+        
         try:
             # 创建移液控制器实例
             if xyz_port:
@@ -755,21 +721,21 @@ if __name__ == "__main__":
             else:
                 print(f"\n🔧 创建移液控制器实例 (端口: {port}, 地址: {address})...")
                 pipette = PipetteController(port=port, address=address)
-
+            
             # 连接设备
             print("\n📞 连接移液器设备...")
             if not pipette.connect():
                 print("❌ 设备连接失败，请检查连接")
                 return
             print("✅ 设备连接成功")
-
+            
             # 初始化设备
             print("\n🚀 初始化设备...")
             if not pipette.initialize():
                 print("❌ 设备初始化失败")
                 return
             print("✅ 设备初始化成功")
-
+            
             # 交互式菜单
             while True:
                 print("\n" + "=" * 50)
@@ -789,9 +755,9 @@ if __name__ == "__main__":
                 print("99. 🚨 紧急停止")
                 print("0. 🚪 退出程序")
                 print("=" * 50)
-
+                
                 choice = input("\n请选择操作 (0-12, 99): ").strip()
-
+                
                 if choice == "0":
                     print("\n👋 退出程序...")
                     break
@@ -807,7 +773,7 @@ if __name__ == "__main__":
                     # print(f"    🔧 枪头使用次数: {status['statistics']['tip_count']}")
                     print(f"    ⬆️  吸液次数: {status['statistics']['aspirate_count']}")
                     print(f"    ⬇️  排液次数: {status['statistics']['dispense_count']}")
-
+                
                 elif choice == "2":
                     # 装载枪头
                     print("\n🔧 装载枪头...")
@@ -815,14 +781,14 @@ if __name__ == "__main__":
                         print("📍 使用 XYZ 控制器进行 Z 轴定位 (下移 10mm)")
                     else:
                         print("⚠️  未连接 XYZ 控制器，仅执行移液器枪头装载")
-
+                    
                     if pipette.pickup_tip():
                         print("✅ 枪头装载成功")
                         if pipette.xyz_connected:
                             print("📍 Z 轴已移动到装载位置")
                     else:
                         print("❌ 枪头装载失败")
-
+                
                 elif choice == "3":
                     # 弹出枪头
                     print("\n🗑️ 弹出枪头...")
@@ -830,7 +796,7 @@ if __name__ == "__main__":
                         print("✅ 枪头弹出成功")
                     else:
                         print("❌ 枪头弹出失败")
-
+                
                 elif choice == "4":
                     # 吸液操作
                     try:
@@ -844,7 +810,7 @@ if __name__ == "__main__":
                             print("❌ 吸液失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "5":
                     # 排液操作
                     try:
@@ -858,7 +824,7 @@ if __name__ == "__main__":
                             print("❌ 排液失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "6":
                     # 混合操作
                     try:
@@ -872,7 +838,7 @@ if __name__ == "__main__":
                             print("❌ 混合失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "7":
                     # 液体转移
                     try:
@@ -880,7 +846,7 @@ if __name__ == "__main__":
                         source = input("源孔位 (可选, 如A1): ").strip() or None
                         dest = input("目标孔位 (可选, 如B1): ").strip() or None
                         new_tip = input("是否使用新枪头? (y/n, 默认y): ").strip().lower() != 'n'
-
+                        
                         print(f"\n🔄 执行液体转移 ({volume}ul)...")
                         if pipette.transfer(volume=volume, source_well=source, dest_well=dest, new_tip=new_tip):
                             print("✅ 液体转移完成")
@@ -888,7 +854,7 @@ if __name__ == "__main__":
                             print("❌ 液体转移失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "8":
                     # 设置液体类型
                     print("\n🧪 可用液体类型:")
@@ -898,16 +864,16 @@ if __name__ == "__main__":
                         "3": (LiquidClass.VISCOUS, "粘稠液体"),
                         "4": (LiquidClass.VOLATILE, "挥发性液体")
                     }
-
+                    
                     for key, (liquid_class, description) in liquid_options.items():
                         print(f"  {key}. {description}")
-
+                    
                     liquid_choice = input("请选择液体类型 (1-4): ").strip()
                     if liquid_choice in liquid_options:
                         liquid_class, description = liquid_options[liquid_choice]
                         pipette.set_liquid_class(liquid_class)
                         print(f"✅ 液体类型设置为: {description}")
-
+                        
                         # 显示参数
                         params = pipette.liquid_params
                         print(f"📋 参数设置:")
@@ -917,7 +883,7 @@ if __name__ == "__main__":
                         print(f"  💧 预润湿: {'是' if params.pre_wet else '否'}")
                     else:
                         print("❌ 无效选择")
-
+                
                 elif choice == "9":
                     # 自定义参数
                     try:
@@ -926,19 +892,19 @@ if __name__ == "__main__":
                         dispense_speed = input("排液速度 (默认800): ").strip()
                         air_gap = input("空气间隙 (ul, 默认10.0): ").strip()
                         pre_wet = input("预润湿 (y/n, 默认n): ").strip().lower() == 'y'
-
+                        
                         custom_params = LiquidParameters(
                             aspirate_speed=int(aspirate_speed) if aspirate_speed else 500,
                             dispense_speed=int(dispense_speed) if dispense_speed else 800,
                             air_gap=float(air_gap) if air_gap else 10.0,
                             pre_wet=pre_wet
                         )
-
+                        
                         pipette.set_custom_parameters(custom_params)
                         print("✅ 自定义参数设置完成")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "10":
                     # 校准体积
                     try:
@@ -948,12 +914,12 @@ if __name__ == "__main__":
                         print(f"✅ 校准完成，校准系数: {actual/expected:.3f}")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-
+                
                 elif choice == "11":
                     # 重置统计
                     pipette.reset_statistics()
                     print("✅ 统计信息已重置")
-
+                
                 elif choice == "12":
                     # 液体类型测试
                     print("\n🧪 液体类型参数对比:")
@@ -963,7 +929,7 @@ if __name__ == "__main__":
                         (LiquidClass.VISCOUS, "粘稠液体"),
                         (LiquidClass.VOLATILE, "挥发性液体")
                     ]
-
+                    
                     for liquid_class, description in liquid_tests:
                         params = pipette.LIQUID_PARAMS[liquid_class]
                         print(f"\n📋 {description} ({liquid_class.value}):")
@@ -972,7 +938,7 @@ if __name__ == "__main__":
                         print(f"  💨 空气间隙: {params.air_gap}ul")
                         print(f"  💧 预润湿: {'是' if params.pre_wet else '否'}")
                         print(f"  ⏱️ 吸液后延时: {params.delay_after_aspirate}s")
-
+                
                 elif choice == "99":
                     # 紧急停止
                     print("\n🚨 执行紧急停止...")
@@ -983,19 +949,19 @@ if __name__ == "__main__":
                     else:
                         print("❌ 紧急停止执行失败")
                         print("⚠️ 请手动检查设备状态并采取必要措施")
-
+                    
                     # 紧急停止后询问是否继续
                     continue_choice = input("\n是否继续操作？(y/n): ").strip().lower()
                     if continue_choice != 'y':
                         print("🚪 退出程序")
                         break
-
+                
                 else:
                     print("❌ 无效选择，请重新输入")
-
+                
                 # 等待用户确认继续
                 input("\n按回车键继续...")
-
+            
         except KeyboardInterrupt:
             print("\n\n⚠️ 用户中断操作")
         except Exception as e:
@@ -1008,19 +974,19 @@ if __name__ == "__main__":
                 print("✅ 连接已断开")
             except:
                 print("⚠️ 断开连接时出现问题")
-
+    
     def demo_test():
         """演示测试模式 - 完整功能演示"""
         print("\n" + "=" * 60)
         print("🎬 移液控制器演示测试")
         print("=" * 60)
-
+        
         try:
             # 创建移液控制器实例
             print("1. 🔧 创建移液控制器实例...")
             pipette = PipetteController(port="/dev/ttyUSB0", address=4)
             print("✅ 移液控制器实例创建成功")
-
+            
             # 连接设备
             print("\n2. 📞 连接移液器设备...")
             if pipette.connect():
@@ -1028,7 +994,7 @@ if __name__ == "__main__":
             else:
                 print("❌ 设备连接失败")
                 return False
-
+            
             # 初始化设备
             print("\n3. 🚀 初始化设备...")
             if pipette.initialize():
@@ -1036,19 +1002,19 @@ if __name__ == "__main__":
             else:
                 print("❌ 设备初始化失败")
                 return False
-
+            
             # 装载枪头
             print("\n4. 🔧 装载枪头...")
             if pipette.pickup_tip():
                 print("✅ 枪头装载成功")
             else:
                 print("❌ 枪头装载失败")
-
+            
             # 设置液体类型
             print("\n5. 🧪 设置液体类型为血清...")
             pipette.set_liquid_class(LiquidClass.SERUM)
             print("✅ 液体类型设置完成")
-
+            
             # 吸液操作
             print("\n6. 💧 执行吸液操作...")
             volume_to_aspirate = 100.0
@@ -1057,7 +1023,7 @@ if __name__ == "__main__":
                 print(f"📊 当前体积: {pipette.current_volume}ul")
             else:
                 print("❌ 吸液失败")
-
+            
             # 排液操作
             print("\n7. 💦 执行排液操作...")
             volume_to_dispense = 50.0
@@ -1066,14 +1032,14 @@ if __name__ == "__main__":
                 print(f"📊 剩余体积: {pipette.current_volume}ul")
             else:
                 print("❌ 排液失败")
-
+            
             # 混合操作
             print("\n8. 🌀 执行混合操作...")
             if pipette.mix(cycles=3, volume=30.0):
                 print("✅ 混合完成")
             else:
                 print("❌ 混合失败")
-
+            
             # 获取状态信息
             print("\n9. 📊 获取设备状态...")
             status = pipette.get_status()
@@ -1086,30 +1052,30 @@ if __name__ == "__main__":
             # print(f"    🔧 枪头使用次数: {status['statistics']['tip_count']}")
             print(f"    ⬆️ 吸液次数: {status['statistics']['aspirate_count']}")
             print(f"    ⬇️ 排液次数: {status['statistics']['dispense_count']}")
-
+            
             # 弹出枪头
             print("\n10. 🗑️ 弹出枪头...")
             if pipette.eject_tip():
                 print("✅ 枪头弹出成功")
             else:
                 print("❌ 枪头弹出失败")
-
+            
             print("\n" + "=" * 60)
             print("✅ 移液控制器演示测试完成")
             print("=" * 60)
-
+            
             return True
-
+            
         except Exception as e:
             print(f"\n❌ 测试过程中发生异常: {e}")
             return False
-
+            
         finally:
             # 断开连接
             print("\n📞 断开连接...")
             pipette.disconnect()
             print("✅ 连接已断开")
-
+    
     # 主程序入口
     print("🧪 移液器控制器测试程序")
     print("=" * 40)
@@ -1117,9 +1083,9 @@ if __name__ == "__main__":
     print("2. 🎬 演示测试")
     print("0. 🚪 退出")
     print("=" * 40)
-
+    
     mode = input("请选择测试模式 (0-2): ").strip()
-
+    
     if mode == "1":
         interactive_test()
     elif mode == "2":
@@ -1128,7 +1094,7 @@ if __name__ == "__main__":
         print("👋 再见！")
     else:
         print("❌ 无效选择")
-
+    
     print("\n🎉 程序结束！")
     print("\n💡 使用说明:")
     print("1. 确保移液器硬件已正确连接")

unilabos/devices/liquid_handling/laiyu/laiyu.py

@@ -13,7 +13,7 @@ from pylabrobot.liquid_handling import (
     SingleChannelDispense,
     PickupTipRack,
     DropTipRack,
-    MultiHeadAspirationPlate,
+    MultiHeadAspirationPlate, ChatterBoxBackend, LiquidHandlerChatterboxBackend,
 )
 from pylabrobot.liquid_handling.standard import (
     MultiHeadAspirationContainer,
@@ -41,6 +41,12 @@ class TransformXYZDeck(Deck):
         super().__init__(name, size_x, size_y, size_z)
         self.name = name
 
+class TransformXYZBackend(LiquidHandlerBackend):
+    def __init__(self, name: str, host: str, port: int, timeout: float):
+        super().__init__()
+        self.host = host
+        self.port = port
+        self.timeout = timeout
 
 class TransformXYZRvizBackend(UniLiquidHandlerRvizBackend):
     def __init__(self, name: str, channel_num: int):
@@ -80,9 +86,7 @@ class TransformXYZContainer(Plate, TipRack):
 class TransformXYZHandler(LiquidHandlerAbstract):
     support_touch_tip = False
 
-    def __init__(self, deck: Deck, host: str = "127.0.0.1", port: int = 9999, timeout: float = 10.0, channel_num=1, simulator=True,
-                 serial_port: str = "/dev/ttyUSB0", baudrate: int = 115200, pipette_address: int = 4,
-                 total_height: float = 310, **backend_kwargs):
+    def __init__(self, deck: Deck, host: str = "127.0.0.1", port: int = 9999, timeout: float = 10.0, channel_num=1, simulator=True, **backend_kwargs):
         # Handle case where deck is passed as a dict (from serialization)
         if isinstance(deck, dict):
             # Try to create a TransformXYZDeck from the dict
@@ -98,22 +102,11 @@ class TransformXYZHandler(LiquidHandlerAbstract):
                 deck = TransformXYZDeck(name='deck', size_x=100, size_y=100, size_z=100)
 
         if simulator:
-            self._unilabos_backend = TransformXYZRvizBackend(name="laiyu", channel_num=channel_num)
+            self._unilabos_backend = TransformXYZRvizBackend(name="laiyu",channel_num=channel_num)
         else:
-            self._unilabos_backend = UniLiquidHandlerLaiyuBackend(
-                num_channels=channel_num,
-                total_height=total_height,
-                port=serial_port,
-                baudrate=baudrate,
-                pipette_address=pipette_address,
-            )
+            self._unilabos_backend = TransformXYZBackend(name="laiyu",host=host, port=port, timeout=timeout)
         super().__init__(backend=self._unilabos_backend, deck=deck, simulator=simulator, channel_num=channel_num)
 
-    def post_init(self, ros_node):
-        super().post_init(ros_node)
-        if hasattr(self._unilabos_backend, 'post_init'):
-            self._unilabos_backend.post_init(ros_node)
-
     async def add_liquid(
         self,
         asp_vols: Union[List[float], float],
@@ -135,25 +128,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         mix_liquid_height: Optional[float] = None,
         none_keys: List[str] = [],
     ):
-        return await super().add_liquid(
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            reagent_sources=reagent_sources,
-            targets=targets,
-            use_channels=use_channels,
-            flow_rates=flow_rates,
-            offsets=offsets,
-            liquid_height=liquid_height,
-            blow_out_air_volume=blow_out_air_volume,
-            spread=spread,
-            is_96_well=is_96_well,
-            delays=delays,
-            mix_time=mix_time,
-            mix_vol=mix_vol,
-            mix_rate=mix_rate,
-            mix_liquid_height=mix_liquid_height,
-            none_keys=none_keys,
-        )
+        pass
 
     async def aspirate(
         self,
@@ -167,17 +142,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         spread: Literal["wide", "tight", "custom"] = "wide",
         **backend_kwargs,
     ):
-        return await super().aspirate(
-            resources=resources,
-            vols=vols,
-            use_channels=use_channels,
-            flow_rates=flow_rates,
-            offsets=offsets,
-            liquid_height=liquid_height,
-            blow_out_air_volume=blow_out_air_volume,
-            spread=spread,
-            **backend_kwargs,
-        )
+        pass
 
     async def dispense(
         self,
@@ -191,17 +156,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         spread: Literal["wide", "tight", "custom"] = "wide",
         **backend_kwargs,
     ):
-        return await super().dispense(
-            resources=resources,
-            vols=vols,
-            use_channels=use_channels,
-            flow_rates=flow_rates,
-            offsets=offsets,
-            liquid_height=liquid_height,
-            blow_out_air_volume=blow_out_air_volume,
-            spread=spread,
-            **backend_kwargs,
-        )
+        pass
 
     async def drop_tips(
         self,
@@ -211,13 +166,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         allow_nonzero_volume: bool = False,
         **backend_kwargs,
     ):
-        return await super().drop_tips(
-            tip_spots=tip_spots,
-            use_channels=use_channels,
-            offsets=offsets,
-            allow_nonzero_volume=allow_nonzero_volume,
-            **backend_kwargs,
-        )
+        pass
 
     async def mix(
         self,
@@ -229,15 +178,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         mix_rate: Optional[float] = None,
         none_keys: List[str] = [],
     ):
-        return await super().mix(
-            targets=targets,
-            mix_time=mix_time,
-            mix_vol=mix_vol,
-            height_to_bottom=height_to_bottom,
-            offsets=offsets,
-            mix_rate=mix_rate,
-            none_keys=none_keys,
-        )
+        pass
 
     async def pick_up_tips(
         self,
@@ -246,12 +187,7 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         offsets: Optional[List[Coordinate]] = None,
         **backend_kwargs,
     ):
-        return await super().pick_up_tips(
-            tip_spots=tip_spots,
-            use_channels=use_channels,
-            offsets=offsets,
-            **backend_kwargs,
-        )
+        pass
 
     async def transfer_liquid(
         self,
@@ -278,26 +214,5 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         delays: Optional[List[int]] = None,
         none_keys: List[str] = [],
     ):
-        return await super().transfer_liquid(
-            sources=sources,
-            targets=targets,
-            tip_racks=tip_racks,
-            use_channels=use_channels,
-            asp_vols=asp_vols,
-            dis_vols=dis_vols,
-            asp_flow_rates=asp_flow_rates,
-            dis_flow_rates=dis_flow_rates,
-            offsets=offsets,
-            touch_tip=touch_tip,
-            liquid_height=liquid_height,
-            blow_out_air_volume=blow_out_air_volume,
-            spread=spread,
-            is_96_well=is_96_well,
-            mix_stage=mix_stage,
-            mix_times=mix_times,
-            mix_vol=mix_vol,
-            mix_rate=mix_rate,
-            mix_liquid_height=mix_liquid_height,
-            delays=delays,
-            none_keys=none_keys,
-        )
+        pass
+    

unilabos/devices/liquid_handling/prcxi/prcxi_modules.py

@@ -0,0 +1,150 @@
+from typing import Any, Dict, Optional
+
+from .prcxi import PRCXI9300ModuleSite
+
+
+class PRCXI9300FunctionalModule(PRCXI9300ModuleSite):
+    """
+    PRCXI 9300 功能模块基类（加热/冷却/震荡/加热震荡/磁吸等）。
+
+    设计目标：
+    - 作为一个可以在工作台上拖拽摆放的实体资源（继承自 PRCXI9300ModuleSite -> ItemizedCarrier）。
+    - 顶面存在一个站点（site），可吸附标准板类资源（plate / tip_rack / tube_rack 等）。
+    - 支持注入 `material_info` (UUID 等)，并且在 serialize_state 时做安全过滤。
+    """
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        module_type: Optional[str] = None,
+        category: str = "module",
+        model: Optional[str] = None,
+        material_info: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            material_info=material_info,
+            model=model,
+            category=category,
+            **kwargs,
+        )
+
+        # 记录模块类型（加热 / 冷却 / 震荡 / 加热震荡 / 磁吸）
+        self.module_type = module_type or "generic"
+
+        # 与 PRCXI9300PlateAdapter 一致，使用 _unilabos_state 保存扩展信息
+        if not hasattr(self, "_unilabos_state") or self._unilabos_state is None:
+            self._unilabos_state = {}
+
+        # super().__init__ 已经在有 material_info 时写入 "Material"，这里仅确保存在
+        if material_info is not None and "Material" not in self._unilabos_state:
+            self._unilabos_state["Material"] = material_info
+
+        # 额外标记 category 和模块类型，便于前端或上层逻辑区分
+        self._unilabos_state.setdefault("category", category)
+        self._unilabos_state["module_type"] = module_type
+
+
+# ============================================================================
+# 具体功能模块定义
+# 这里的尺寸和 material_info 目前为占位参数，后续可根据实际测量/JSON 配置进行更新。
+# 顶面站点尺寸与模块外形一致，保证可以吸附标准 96 板/储液槽等。
+# ============================================================================
+
+
+def PRCXI_Heating_Module(name: str) -> PRCXI9300FunctionalModule:
+    """加热模块（顶面可吸附标准板）。"""
+    return PRCXI9300FunctionalModule(
+        name=name,
+        size_x=127.76,
+        size_y=85.48,
+        size_z=40.0,
+        module_type="heating",
+        model="PRCXI_Heating_Module",
+        material_info={
+            "uuid": "TODO-HEATING-MODULE-UUID",
+            "Code": "HEAT-MOD",
+            "Name": "PRCXI 加热模块",
+            "SupplyType": 3,
+        },
+    )
+
+
+def PRCXI_MetalCooling_Module(name: str) -> PRCXI9300FunctionalModule:
+    """金属冷却模块（顶面可吸附标准板）。"""
+    return PRCXI9300FunctionalModule(
+        name=name,
+        size_x=127.76,
+        size_y=85.48,
+        size_z=40.0,
+        module_type="metal_cooling",
+        model="PRCXI_MetalCooling_Module",
+        material_info={
+            "uuid": "TODO-METAL-COOLING-MODULE-UUID",
+            "Code": "METAL-COOL-MOD",
+            "Name": "PRCXI 金属冷却模块",
+            "SupplyType": 3,
+        },
+    )
+
+
+def PRCXI_Shaking_Module(name: str) -> PRCXI9300FunctionalModule:
+    """震荡模块（顶面可吸附标准板）。"""
+    return PRCXI9300FunctionalModule(
+        name=name,
+        size_x=127.76,
+        size_y=85.48,
+        size_z=50.0,
+        module_type="shaking",
+        model="PRCXI_Shaking_Module",
+        material_info={
+            "uuid": "TODO-SHAKING-MODULE-UUID",
+            "Code": "SHAKE-MOD",
+            "Name": "PRCXI 震荡模块",
+            "SupplyType": 3,
+        },
+    )
+
+
+def PRCXI_Heating_Shaking_Module(name: str) -> PRCXI9300FunctionalModule:
+    """加热震荡模块（顶面可吸附标准板）。"""
+    return PRCXI9300FunctionalModule(
+        name=name,
+        size_x=127.76,
+        size_y=85.48,
+        size_z=55.0,
+        module_type="heating_shaking",
+        model="PRCXI_Heating_Shaking_Module",
+        material_info={
+            "uuid": "TODO-HEATING-SHAKING-MODULE-UUID",
+            "Code": "HEAT-SHAKE-MOD",
+            "Name": "PRCXI 加热震荡模块",
+            "SupplyType": 3,
+        },
+    )
+
+
+def PRCXI_Magnetic_Module(name: str) -> PRCXI9300FunctionalModule:
+    """磁吸模块（顶面可吸附标准板）。"""
+    return PRCXI9300FunctionalModule(
+        name=name,
+        size_x=127.76,
+        size_y=85.48,
+        size_z=30.0,
+        module_type="magnetic",
+        model="PRCXI_Magnetic_Module",
+        material_info={
+            "uuid": "TODO-MAGNETIC-MODULE-UUID",
+            "Code": "MAG-MOD",
+            "Name": "PRCXI 磁吸模块",
+            "SupplyType": 3,
+        },
+    )
+

unilabos/devices/liquid_handling/rviz_backend.py

@@ -59,6 +59,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     self.total_height = total_height
     self.joint_config = kwargs.get("joint_config", None)
     self.lh_device_id = kwargs.get("lh_device_id", "lh_joint_publisher")
+    self.simulate_rviz = kwargs.get("simulate_rviz", False)
     if not rclpy.ok():
         rclpy.init()
     self.joint_state_publisher = None
@@ -69,7 +70,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     self.joint_state_publisher = LiquidHandlerJointPublisher(
                                 joint_config=self.joint_config,
                                 lh_device_id=self.lh_device_id,
-                                simulate_rviz=True)
+                                simulate_rviz=self.simulate_rviz)
 
     # 启动ROS executor
     self.executor = rclpy.executors.MultiThreadedExecutor()

unilabos/devices/motor/ZDT_X42.py

@@ -1,376 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-ZDT X42 Closed-Loop Stepper Motor Driver
-RS485 Serial Communication via USB-Serial Converter
-
-- Baudrate: 115200
-"""
-
-import serial
-import time
-import threading
-import struct
-import logging
-from typing import Optional, Any
-
-try:
-    from unilabos.device_comms.universal_driver import UniversalDriver
-except ImportError:
-    class UniversalDriver:
-        def __init__(self, *args, **kwargs):
-            self.logger = logging.getLogger(self.__class__.__name__)
-        def execute_command_from_outer(self, command: Any): pass
-
-from serial.rs485 import RS485Settings
-
-
-class ZDTX42Driver(UniversalDriver):
-    """
-    ZDT X42 闭环步进电机驱动器
-
-    支持功能:
-    - 速度模式运行
-    - 位置模式运行 (相对/绝对)
-    - 位置读取和清零
-    - 使能/禁用控制
-
-    通信协议:
-    - 帧格式: [设备ID] [功能码] [数据...] [校验位=0x6B]
-    - 响应长度根据功能码决定
-    """
-
-    def __init__(
-        self,
-        port: str,
-        baudrate: int = 115200,
-        device_id: int = 1,
-        timeout: float = 0.5,
-        debug: bool = False
-    ):
-        """
-        初始化 ZDT X42 电机驱动
-
-        Args:
-            port: 串口设备路径
-            baudrate: 波特率 (默认 115200)
-            device_id: 设备地址 (1-255)
-            timeout: 通信超时时间(秒)
-            debug: 是否启用调试输出
-        """
-        super().__init__()
-        self.id = device_id
-        self.debug = debug
-        self.lock = threading.RLock()
-        self.status = "idle"         # 对应注册表中的 status (str)
-        self.position = 0             # 对应注册表中的 position (int)
-
-        try:
-            self.ser = serial.Serial(
-                port=port,
-                baudrate=baudrate,
-                timeout=timeout,
-                bytesize=serial.EIGHTBITS,
-                parity=serial.PARITY_NONE,
-                stopbits=serial.STOPBITS_ONE
-            )
-
-            # 启用 RS485 模式
-            try:
-                self.ser.rs485_mode = RS485Settings(
-                    rts_level_for_tx=True,
-                    rts_level_for_rx=False
-                )
-            except Exception:
-                pass  # RS485 模式是可选的
-
-            self.logger.info(
-                f"ZDT X42 Motor connected: {port} "
-                f"(Baud: {baudrate}, ID: {device_id})"
-            )
-            # 自动使能电机，确保初始状态可运动
-            self.enable(True)
-
-            # 启动背景轮询线程，确保 position 实时刷新
-            self._stop_event = threading.Event()
-            self._polling_thread = threading.Thread(
-                target=self._update_loop,
-                name=f"ZDTPolling_{port}",
-                daemon=True
-            )
-            self._polling_thread.start()
-        except Exception as e:
-            self.logger.error(f"Failed to open serial port {port}: {e}")
-            self.ser = None
-
-    def _update_loop(self):
-        """背景循环读取电机位置"""
-        while not self._stop_event.is_set():
-            try:
-                self.get_position()
-            except Exception as e:
-                if self.debug:
-                    self.logger.error(f"Polling error: {e}")
-            time.sleep(1.0) # 每1秒刷新一次位置数据
-
-    def _send(self, func_code: int, payload: list) -> bytes:
-        """
-        发送指令并接收响应
-
-        Args:
-            func_code: 功能码
-            payload: 数据负载 (list of bytes)
-
-        Returns:
-            响应数据 (bytes)
-        """
-        if not self.ser:
-            self.logger.error("Serial port not available")
-            return b""
-
-        with self.lock:
-            # 清空输入缓冲区
-            self.ser.reset_input_buffer()
-
-            # 构建消息: [ID] [功能码] [数据...] [校验位=0x6B]
-            message = bytes([self.id, func_code] + payload + [0x6B])
-
-            # 发送
-            self.ser.write(message)
-
-            # 根据功能码决定响应长度
-            # 查询类指令返回 10 字节，控制类指令返回 4 字节
-            read_len = 10 if func_code in [0x31, 0x32, 0x35, 0x24, 0x27] else 4
-            response = self.ser.read(read_len)
-
-            # 调试输出
-            if self.debug:
-                sent_hex = message.hex().upper()
-                recv_hex = response.hex().upper() if response else 'TIMEOUT'
-                print(f"[ID {self.id}] TX: {sent_hex} → RX: {recv_hex}")
-
-            return response
-
-    def enable(self, on: bool = True) -> bool:
-        """
-        使能/禁用电机
-
-        Args:
-            on: True=使能(锁轴), False=禁用(松轴)
-
-        Returns:
-            是否成功
-        """
-        state = 1 if on else 0
-        resp = self._send(0xF3, [0xAB, state, 0])
-        return len(resp) >= 4
-
-    def move_speed(
-        self,
-        speed_rpm: int,
-        direction: str = "CW",
-        acceleration: int = 10
-    ) -> bool:
-        """
-        速度模式运行
-
-        Args:
-            speed_rpm: 转速 (RPM)
-            direction: 方向 ("CW"=顺时针, "CCW"=逆时针)
-            acceleration: 加速度 (0-255)
-
-        Returns:
-            是否成功
-        """
-        dir_val = 0 if direction.upper() in ["CW", "顺时针"] else 1
-        speed_bytes = struct.pack('>H', int(speed_rpm))
-        self.status = f"moving@{speed_rpm}rpm"
-        resp = self._send(0xF6, [dir_val, speed_bytes[0], speed_bytes[1], acceleration, 0])
-        return len(resp) >= 4
-
-    def move_position(
-        self,
-        pulses: int,
-        speed_rpm: int,
-        direction: str = "CW",
-        acceleration: int = 10,
-        absolute: bool = False
-    ) -> bool:
-        """
-        位置模式运行
-
-        Args:
-            pulses: 脉冲数
-            speed_rpm: 转速 (RPM)
-            direction: 方向 ("CW"=顺时针, "CCW"=逆时针)
-            acceleration: 加速度 (0-255)
-            absolute: True=绝对位置, False=相对位置
-
-        Returns:
-            是否成功
-        """
-        dir_val = 0 if direction.upper() in ["CW", "顺时针"] else 1
-        speed_bytes = struct.pack('>H', int(speed_rpm))
-        self.status = f"moving_to_{pulses}"
-        pulse_bytes = struct.pack('>I', int(pulses))
-        abs_flag = 1 if absolute else 0
-
-        payload = [
-            dir_val,
-            speed_bytes[0], speed_bytes[1],
-            acceleration,
-            pulse_bytes[0], pulse_bytes[1], pulse_bytes[2], pulse_bytes[3],
-            abs_flag,
-            0
-        ]
-
-        resp = self._send(0xFD, payload)
-        return len(resp) >= 4
-
-    def stop(self) -> bool:
-        """
-        停止电机
-
-        Returns:
-            是否成功
-        """
-        self.status = "idle"
-        resp = self._send(0xFE, [0x98, 0])
-        return len(resp) >= 4
-
-    def rotate_quarter(self, speed_rpm: int = 60, direction: str = "CW") -> bool:
-        """
-        电机旋转 1/4 圈 (阻塞式)
-        假设电机细分为 3200 脉冲/圈，1/4 圈 = 800 脉冲
-        """
-        pulses = 800
-        success = self.move_position(pulses=pulses, speed_rpm=speed_rpm, direction=direction, absolute=False)
-
-        if success:
-            # 计算预估旋转时间并进行阻塞等待 (Time = revolutions / (RPM/60))
-            # 1/4 rev / (RPM/60) = 15.0 / RPM
-            estimated_time = 15.0 / max(1, speed_rpm)
-            time.sleep(estimated_time + 0.5)  # 额外给 0.5 秒缓冲
-            self.status = "idle"
-
-        return success
-
-    def wait_time(self, duration_s: float) -> bool:
-        """
-        等待指定时间 (秒)
-        """
-        self.logger.info(f"Waiting for {duration_s} seconds...")
-        time.sleep(duration_s)
-        return True
-
-    def set_zero(self) -> bool:
-        """
-        清零当前位置
-
-        Returns:
-            是否成功
-        """
-        resp = self._send(0x0A, [])
-        return len(resp) >= 4
-
-    def get_position(self) -> Optional[int]:
-        """
-        读取当前位置 (脉冲数)
-
-        Returns:
-            当前位置脉冲数，失败返回 None
-        """
-        resp = self._send(0x32, [])
-
-        if len(resp) >= 8:
-            # 响应格式: [ID] [Func] [符号位] [数值4字节] [校验]
-            sign = resp[2]  # 0=正, 1=负
-            value = struct.unpack('>I', resp[3:7])[0]
-            self.position = -value if sign == 1 else value
-
-            if self.debug:
-                print(f"[Position] Raw: {resp.hex().upper()}, Parsed: {self.position}")
-
-            return self.position
-
-        self.logger.warning("Failed to read position")
-        return None
-
-    def close(self):
-        """关闭串口连接并停止线程"""
-        if hasattr(self, '_stop_event'):
-            self._stop_event.set()
-
-        if self.ser and self.ser.is_open:
-            self.ser.close()
-            self.logger.info("Serial port closed")
-
-
-# ============================================================
-# 测试和调试代码
-# ============================================================
-
-def test_motor():
-    """基础功能测试"""
-    logging.basicConfig(level=logging.INFO)
-
-    print("="*60)
-    print("ZDT X42 电机驱动测试")
-    print("="*60)
-
-    driver = ZDTX42Driver(
-        port="/dev/tty.usbserial-3110",
-        baudrate=115200,
-        device_id=2,
-        debug=True
-    )
-
-    if not driver.ser:
-        print("❌ 串口打开失败")
-        return
-
-    try:
-        # 测试 1: 读取位置
-        print("\n[1] 读取当前位置")
-        pos = driver.get_position()
-        print(f"✓ 当前位置: {pos} 脉冲")
-
-        # 测试 2: 使能
-        print("\n[2] 使能电机")
-        driver.enable(True)
-        time.sleep(0.3)
-        print("✓ 电机已锁定")
-
-        # 测试 3: 相对位置运动
-        print("\n[3] 相对位置运动 (1000脉冲)")
-        driver.move_position(pulses=1000, speed_rpm=60, direction="CW")
-        time.sleep(2)
-        pos = driver.get_position()
-        print(f"✓ 新位置: {pos}")
-
-        # 测试 4: 速度运动
-        print("\n[4] 速度模式 (30RPM, 3秒)")
-        driver.move_speed(speed_rpm=30, direction="CW")
-        time.sleep(3)
-        driver.stop()
-        pos = driver.get_position()
-        print(f"✓ 停止后位置: {pos}")
-
-        # 测试 5: 禁用
-        print("\n[5] 禁用电机")
-        driver.enable(False)
-        print("✓ 电机已松开")
-
-        print("\n" + "="*60)
-        print("✅ 测试完成")
-        print("="*60)
-
-    except Exception as e:
-        print(f"\n❌ 测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-    finally:
-        driver.close()
-
-
-if __name__ == "__main__":
-    test_motor()

unilabos/devices/ros_dev/liquid_handler_joint_publisher_node.py

@@ -42,6 +42,7 @@ class LiquidHandlerJointPublisher(Node):
             while self.resource_action is None:
                 self.resource_action = self.check_tf_update_actions()
                 time.sleep(1)
+                self.get_logger().info(f'Waiting for TfUpdate server: {self.resource_action}')
 
             self.resource_action_client = ActionClient(self, SendCmd, self.resource_action)
             while not self.resource_action_client.wait_for_server(timeout_sec=1.0):

unilabos/devices/separator/chinwe.py

@@ -623,119 +623,6 @@ class ChinweDevice(UniversalDriver):
         time.sleep(duration)
         return True
 
-    def separation_step(self, motor_id: int = 5, speed: int = 60, pulses: int = 700,
-                       max_cycles: int = 0, timeout: int = 300) -> bool:
-        """
-        分液步骤 - 液位传感器与电机联动
-        当液位传感器检测到"有液"时,电机顺时针旋转指定脉冲数
-        当液位传感器检测到"无液"时,电机逆时针旋转指定脉冲数
-
-        :param motor_id: 电机ID (必须在初始化时配置的motor_ids中)
-        :param speed: 电机转速 (RPM)
-        :param pulses: 每次旋转的脉冲数 (默认700约为1/4圈,假设3200脉冲/圈)
-        :param max_cycles: 最大执行循环次数 (0=无限制,默认0)
-        :param timeout: 整体超时时间 (秒)
-        :return: 成功返回True,超时或失败返回False
-        """
-        motor_id = int(motor_id)
-        speed = int(speed)
-        pulses = int(pulses)
-        max_cycles = int(max_cycles)
-        timeout = int(timeout)
-
-        # 检查电机是否存在
-        if motor_id not in self.motors:
-            self.logger.error(f"Motor {motor_id} not found in configured motors: {list(self.motors.keys())}")
-            return False
-
-        # 检查传感器是否可用
-        if not self.sensor:
-            self.logger.error("Sensor not initialized")
-            return False
-
-        motor = self.motors[motor_id]
-
-        # 停止轮询线程，避免与 separation_step 同时读取传感器造成串口冲突
-        self.logger.info("Stopping polling thread for separation_step...")
-        self._stop_event.set()
-        if self._poll_thread and self._poll_thread.is_alive():
-            self._poll_thread.join(timeout=2.0)
-
-        # 使能电机
-        self.logger.info(f"Enabling motor {motor_id}...")
-        motor.enable(True)
-        time.sleep(0.2)
-
-        self.logger.info(f"Starting separation step: motor_id={motor_id}, speed={speed} RPM, "
-                        f"pulses={pulses}, max_cycles={max_cycles}, timeout={timeout}s")
-
-        # 记录上一次的液位状态
-        last_level = None
-        cycle_count = 0
-        start_time = time.time()
-        error_count = 0
-
-        try:
-            while True:
-                # 检查超时
-                if time.time() - start_time > timeout:
-                    self.logger.warning(f"Separation step timeout after {timeout} seconds")
-                    return False
-
-                # 检查循环次数限制
-                if max_cycles > 0 and cycle_count >= max_cycles:
-                    self.logger.info(f"Separation step completed: reached max_cycles={max_cycles}")
-                    return True
-
-                # 读取传感器数据
-                data = self.sensor.read_level()
-
-                if data is None:
-                    error_count += 1
-                    if error_count > 5:
-                        self.logger.warning("Sensor read failed multiple times, retrying...")
-                        error_count = 0
-                    time.sleep(0.5)
-                    continue
-
-                error_count = 0
-                current_level = data['level']
-                rssi = data['rssi']
-
-                # 检测状态变化 (包括首次检测)
-                if current_level != last_level:
-                    cycle_count += 1
-
-                    if current_level:
-                        # 有液 -> 电机顺时针旋转
-                        self.logger.info(f"[Cycle {cycle_count}] Liquid detected (RSSI={rssi}), "
-                                       f"rotating motor {motor_id} clockwise {pulses} pulses")
-                        motor.run_position(pulses=pulses, speed_rpm=speed, direction=0, absolute=False)
-
-                        # 等待电机完成 (预估时间)
-                        estimated_time = 15.0 / max(1, speed)
-                        time.sleep(estimated_time + 0.5)
-
-                    else:
-                        # 无液 -> 电机逆时针旋转
-                        self.logger.info(f"[Cycle {cycle_count}] No liquid detected (RSSI={rssi}), "
-                                       f"rotating motor {motor_id} counter-clockwise {pulses} pulses")
-                        motor.run_position(pulses=pulses, speed_rpm=speed, direction=1, absolute=False)
-
-                        # 等待电机完成 (预估时间)
-                        estimated_time = 15.0 / max(1, speed)
-                        time.sleep(estimated_time + 0.5)
-
-                # 更新状态
-                last_level = current_level
-
-                # 轮询间隔
-                time.sleep(0.1)
-        finally:
-            # 恢复轮询线程
-            self.logger.info("Restarting polling thread...")
-            self._start_polling()
-
     def execute_command_from_outer(self, command_dict: Dict[str, Any]) -> bool:
         """支持标准 JSON 指令调用"""
         return super().execute_command_from_outer(command_dict)

unilabos/devices/separator/xkc_sensor.py

@@ -1,379 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-XKC RS485 液位传感器 (Modbus RTU)
-
-说明:
-    1. 遵循 Modbus-RTU 协议。
-    2. 数据寄存器: 0x0001 (液位状态, 1=有液, 0=无液), 0x0002 (RSSI 信号强度)。
-    3. 地址寄存器: 0x0004 (可读写, 范围 1-254)。
-    4. 波特率寄存器: 0x0005 (可写, 代码表见 change_baudrate 方法)。
-"""
-
-import struct
-import threading
-import time
-import logging
-import serial
-from typing import Optional, Dict, Any, List
-
-from unilabos.device_comms.universal_driver import UniversalDriver
-
-class TransportManager:
-    """
-    统一通信管理类。
-    仅支持 串口 (Serial/有线) 连接。
-    """
-    def __init__(self, port: str, baudrate: int = 9600, timeout: float = 3.0, logger=None):
-        self.port = port
-        self.baudrate = baudrate
-        self.timeout = timeout
-        self.logger = logger
-        self.lock = threading.RLock() # 线程锁，确保多设备共用一个连接时不冲突
-
-        self.serial = None
-        self._connect_serial()
-
-    def _connect_serial(self):
-        try:
-            self.serial = serial.Serial(
-                port=self.port,
-                baudrate=self.baudrate,
-                timeout=self.timeout
-            )
-        except Exception as e:
-            raise ConnectionError(f"Serial open failed: {e}")
-
-    def close(self):
-        """关闭连接"""
-        if self.serial and self.serial.is_open:
-            self.serial.close()
-
-    def clear_buffer(self):
-        """清空缓冲区 (Thread-safe)"""
-        with self.lock:
-            if self.serial:
-                self.serial.reset_input_buffer()
-
-    def write(self, data: bytes):
-        """发送原始字节"""
-        with self.lock:
-            if self.serial:
-                self.serial.write(data)
-
-    def read(self, size: int) -> bytes:
-        """读取指定长度字节"""
-        if self.serial:
-            return self.serial.read(size)
-        return b''
-
-class XKCSensorDriver(UniversalDriver):
-    """XKC RS485 液位传感器 (Modbus RTU)"""
-
-    def __init__(self, port: str, baudrate: int = 9600, device_id: int = 6,
-                 threshold: int = 300, timeout: float = 3.0, debug: bool = False):
-        super().__init__()
-        self.port = port
-        self.baudrate = baudrate
-        self.device_id = device_id
-        self.threshold = threshold
-        self.timeout = timeout
-        self.debug = debug
-        self.level = False
-        self.rssi = 0
-        self.status = {"level": self.level, "rssi": self.rssi}
-
-        try:
-            self.transport = TransportManager(port, baudrate, timeout, logger=self.logger)
-            self.logger.info(f"XKCSensorDriver connected to {port} (ID: {device_id})")
-        except Exception as e:
-            self.logger.error(f"Failed to connect XKCSensorDriver: {e}")
-            self.transport = None
-
-        # 启动背景轮询线程，确保 status 实时刷新
-        self._stop_event = threading.Event()
-        self._polling_thread = threading.Thread(
-            target=self._update_loop,
-            name=f"XKCPolling_{port}",
-            daemon=True
-        )
-        if self.transport:
-            self._polling_thread.start()
-
-    def _update_loop(self):
-        """背景循环读取传感器数据"""
-        while not self._stop_event.is_set():
-            try:
-                self.read_level()
-            except Exception as e:
-                if self.debug:
-                    self.logger.error(f"Polling error: {e}")
-            time.sleep(2.0) # 每2秒刷新一次数据
-
-    def _crc(self, data: bytes) -> bytes:
-        crc = 0xFFFF
-        for byte in data:
-            crc ^= byte
-            for _ in range(8):
-                if crc & 0x0001: crc = (crc >> 1) ^ 0xA001
-                else: crc >>= 1
-        return struct.pack('<H', crc)
-
-    def read_level(self) -> Optional[Dict[str, Any]]:
-        """
-        读取液位。
-        返回: {'level': bool, 'rssi': int}
-        """
-        if not self.transport:
-            return None
-
-        with self.transport.lock:
-            self.transport.clear_buffer()
-            # Modbus Read Registers: 01 03 00 01 00 02 CRC
-            payload = struct.pack('>HH', 0x0001, 0x0002)
-            msg = struct.pack('BB', self.device_id, 0x03) + payload
-            msg += self._crc(msg)
-
-            if self.debug:
-                self.logger.info(f"TX (ID {self.device_id}): {msg.hex().upper()}")
-
-            self.transport.write(msg)
-
-            # Read header
-            h = self.transport.read(3) # Addr, Func, Len
-            if self.debug:
-                self.logger.info(f"RX Header: {h.hex().upper()}")
-
-            if len(h) < 3: return None
-            length = h[2]
-
-            # Read body + CRC
-            body = self.transport.read(length + 2)
-            if self.debug:
-                self.logger.info(f"RX Body+CRC: {body.hex().upper()}")
-            if len(body) < length + 2:
-                # Firmware bug fix specific to some modules
-                if len(body) == 4 and length == 4:
-                    pass
-                else:
-                    return None
-
-            data = body[:-2]
-            # 根据手册说明:
-            # 寄存器 0x0001 (data[0:2]): 液位状态 (00 01 为有液, 00 00 为无液)
-            # 寄存器 0x0002 (data[2:4]): 信号强度 RSSI
-
-            hw_level = False
-            rssi = 0
-
-            if len(data) >= 4:
-                hw_level = ((data[0] << 8) | data[1]) == 1
-                rssi = (data[2] << 8) | data[3]
-            elif len(data) == 2:
-                # 兼容模式: 某些老固件可能只返回 1 个寄存器
-                rssi = (data[0] << 8) | data[1]
-                hw_level = rssi > self.threshold
-            else:
-                return None
-
-            # 最终判定: 优先使用硬件层级的 level 判定，但 RSSI 阈值逻辑作为补充/校验
-            # 注意: 如果用户显式设置了 THRESHOLD，我们可以在逻辑中做权衡
-            self.level = hw_level or (rssi > self.threshold)
-            self.rssi = rssi
-            result = {
-                'level': self.level,
-                'rssi': self.rssi
-            }
-            self.status = result
-            return result
-
-    def wait_level(self, target_state: bool, timeout: float = 60.0) -> bool:
-        """
-        等待液位达到目标状态 (阻塞式)
-        """
-        self.logger.info(f"Waiting for level: {target_state}")
-        start_time = time.time()
-        while (time.time() - start_time) < timeout:
-            res = self.read_level()
-            if res and res.get('level') == target_state:
-                return True
-            time.sleep(0.5)
-        self.logger.warning(f"Wait level timeout ({timeout}s)")
-        return False
-
-    def wait_for_liquid(self, target_state: bool, timeout: float = 120.0) -> bool:
-        """
-        实时检测电导率(RSSI)并等待用户指定的“有液”或“无液”状态。
-        一旦检测到符合目标状态，立即返回。
-
-        Args:
-            target_state: True 为“有液”, False 为“无液”
-            timeout: 最大等待时间(秒)
-        """
-        state_str = "有液" if target_state else "无液"
-        self.logger.info(f"开始实时检测电导率，等待状态: {state_str} (超时: {timeout}s)")
-
-        start_time = time.time()
-        while (time.time() - start_time) < timeout:
-            res = self.read_level() # 内部已更新 self.level 和 self.rssi
-            if res:
-                current_level = res.get('level')
-                current_rssi = res.get('rssi')
-                if current_level == target_state:
-                    self.logger.info(f"✅ 检测到目标状态: {state_str} (当前电导率/RSSI: {current_rssi})")
-                    return True
-
-                if self.debug:
-                    self.logger.debug(f"当前状态: {'有液' if current_level else '无液'}, RSSI: {current_rssi}")
-
-            time.sleep(0.2) # 高频采样
-
-        self.logger.warning(f"❌ 等待 {state_str} 状态超时 ({timeout}s)")
-        return False
-
-    def set_threshold(self, threshold: int):
-        """设置液位判定阈值"""
-        self.threshold = int(threshold)
-        self.logger.info(f"Threshold updated to: {self.threshold}")
-
-    def change_device_id(self, new_id: int) -> bool:
-        """
-        修改设备的 Modbus 从站地址。
-        寄存器: 0x0004, 功能码: 0x06
-        """
-        if not (1 <= new_id <= 254):
-            self.logger.error(f"Invalid device ID: {new_id}. Must be 1-254.")
-            return False
-
-        self.logger.info(f"Changing device ID from {self.device_id} to {new_id}")
-        success = self._write_single_register(0x0004, new_id)
-        if success:
-            self.device_id = new_id # 更新内存中的地址
-            self.logger.info(f"Device ID update command sent successfully (target {new_id}).")
-        return success
-
-    def change_baudrate(self, baud_code: int) -> bool:
-        """
-        更改通讯波特率 (寄存器: 0x0005)。
-        设置成功后传感器 LED 会闪烁，通常无数据返回。
-
-        波特率代码对照表 (16进制):
-        05: 2400
-        06: 4800
-        07: 9600 (默认)
-        08: 14400
-        09: 19200
-        0A: 28800
-        0C: 57600
-        0D: 115200
-        0E: 128000
-        0F: 256000
-        """
-        self.logger.info(f"Sending baudrate change command (Code: {baud_code:02X})")
-        # 写入寄存器 0x0005
-        self._write_single_register(0x0005, baud_code)
-        self.logger.info("Baudrate change command executed. Device LED should flash. Please update connection settings.")
-        return True
-
-    def factory_reset(self) -> bool:
-        """
-        恢复出厂设置 (通过广播地址 FF)。
-        设置地址为 01，逻辑为向 0x0004 写入 0x0002
-        """
-        self.logger.info("Sending factory reset command via broadcast address FF...")
-        # 广播指令通常无回显
-        self._write_single_register(0x0004, 0x0002, slave_id=0xFF)
-        self.logger.info("Factory reset command sent. Device address should be 01 now.")
-        return True
-
-    def _write_single_register(self, reg_addr: int, value: int, slave_id: Optional[int] = None) -> bool:
-        """内部辅助函数: Modbus 功能码 06 写单个寄存器"""
-        if not self.transport: return False
-
-        target_id = slave_id if slave_id is not None else self.device_id
-        msg = struct.pack('BBHH', target_id, 0x06, reg_addr, value)
-        msg += self._crc(msg)
-
-        with self.transport.lock:
-            self.transport.clear_buffer()
-            if self.debug:
-                self.logger.info(f"TX Write (Reg {reg_addr:#06x}): {msg.hex().upper()}")
-
-            self.transport.write(msg)
-
-            # 广播地址、波特率修改或厂家特定指令可能无回显
-            if target_id == 0xFF or reg_addr == 0x0005:
-                time.sleep(0.5)
-                return True
-
-            # 等待返回 (正常应返回相同报文)
-            resp = self.transport.read(len(msg))
-            if self.debug:
-                self.logger.info(f"RX Write Response: {resp.hex().upper()}")
-
-            return resp == msg
-
-    def close(self):
-        if self.transport:
-            self.transport.close()
-
-if __name__ == "__main__":
-    # 快速实例化测试
-    import logging
-    # 减少冗余日志，仅显示重要信息
-    logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
-
-    # 硬件配置 (根据实际情况修改)
-    TEST_PORT = "/dev/tty.usbserial-3110"
-    SLAVE_ID = 1
-    THRESHOLD = 300
-
-    print("\n" + "="*50)
-    print(f"  XKC RS485 传感器独立测试程序")
-    print(f"  端口: {TEST_PORT} | 地址: {SLAVE_ID} | 阈值: {THRESHOLD}")
-    print("="*50)
-
-    sensor = XKCSensorDriver(port=TEST_PORT, device_id=SLAVE_ID, threshold=THRESHOLD, debug=False)
-
-    try:
-        if sensor.transport:
-            print(f"\n开始实时连续采样测试 (持续 15 秒)...")
-            print(f"按 Ctrl+C 可提前停止\n")
-
-            start_time = time.time()
-            duration = 15
-            count = 0
-
-            while time.time() - start_time < duration:
-                count += 1
-                res = sensor.read_level()
-                if res:
-                    rssi = res['rssi']
-                    level = res['level']
-                    status_str = "【有液】" if level else "【无液】"
-                    # 使用 \r 实现单行刷新显示 (或者不刷，直接打印历史)
-                    # 为了方便查看变化，我们直接打印
-                    elapsed = time.time() - start_time
-                    print(f" [{elapsed:4.1f}s] 采样 {count:<3}: 电导率/RSSI = {rssi:<5} | 判定结果: {status_str}")
-                else:
-                    print(f" [{time.time()-start_time:4.1f}s] 采样 {count:<3}: 通信失败 (无响应)")
-
-                time.sleep(0.5) # 每秒采样 2 次
-
-            print(f"\n--- 15 秒采样测试完成 (总计 {count} 次) ---")
-
-            # [3] 测试动态修改阈值
-            print(f"\n[3] 动态修改阈值演示...")
-            new_threshold = 400
-            sensor.set_threshold(new_threshold)
-            res = sensor.read_level()
-            if res:
-                print(f"  采样 (当前阈值={new_threshold}): 电导率/RSSI = {res['rssi']:<5} | 判定结果: {'【有液】' if res['level'] else '【无液】'}")
-            sensor.set_threshold(THRESHOLD) # 还原
-
-    except KeyboardInterrupt:
-        print("\n[!] 用户中断测试")
-    except Exception as e:
-        print(f"\n[!] 测试运行出错: {e}")
-    finally:
-        sensor.close()
-        print("\n--- 测试程序已退出 ---\n")

unilabos/devices/virtual/virtual_multiway_valve.py

@@ -2,8 +2,6 @@ import time
 import logging
 from typing import Union, Dict, Optional
 
-from unilabos.registry.decorators import topic_config
-
 
 class VirtualMultiwayValve:
     """
@@ -43,11 +41,13 @@ class VirtualMultiwayValve:
     def target_position(self) -> int:
         return self._target_position
 
-    @property
-    @topic_config()
-    def current_port(self) -> str:
-        """当前连接的端口名称 🔌"""
-        return self.port
+    def get_current_position(self) -> int:
+        """获取当前阀门位置 📍"""
+        return self._current_position
+
+    def get_current_port(self) -> str:
+        """获取当前连接的端口名称 🔌"""
+        return self._current_position
 
     def set_position(self, command: Union[int, str]):
         """
@@ -169,14 +169,12 @@ class VirtualMultiwayValve:
         self._status = "Idle"
         self._valve_state = "Closed"
         
-        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.port})"
+        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.get_current_port()})"
         self.logger.info(close_msg)
         return close_msg
 
-    @property
-    @topic_config()
-    def valve_position(self) -> int:
-        """阀门位置 📍"""
+    def get_valve_position(self) -> int:
+        """获取阀门位置 - 兼容性方法 📍"""
         return self._current_position
 
     def set_valve_position(self, command: Union[int, str]):
@@ -231,16 +229,19 @@ class VirtualMultiwayValve:
             self.logger.info(f"🔄 从端口 {self._current_position} 切换到泵位置...")
             return self.set_to_pump_position()
 
-    @property
-    @topic_config()
-    def flow_path(self) -> str:
-        """当前流路路径描述 🌊"""
+    def get_flow_path(self) -> str:
+        """获取当前流路路径描述 🌊"""
+        current_port = self.get_current_port()
         if self._current_position == 0:
-            return f"🚰 转移泵已连接 (位置 {self._current_position})"
-        return f"🔌 端口 {self._current_position} 已连接 ({self.current_port})"
+            flow_path = f"🚰 转移泵已连接 (位置 {self._current_position})"
+        else:
+            flow_path = f"🔌 端口 {self._current_position} 已连接 ({current_port})"
+        
+        # 删除debug日志：self.logger.debug(f"🌊 当前流路: {flow_path}")
+        return flow_path
 
     def __str__(self):
-        current_port = self.current_port
+        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})"
@@ -252,7 +253,7 @@ if __name__ == "__main__":
     
     print("🔄 === 虚拟九通阀门测试 === ✨")
     print(f"🏠 初始状态: {valve}")
-    print(f"🌊 当前流路: {valve.flow_path}")
+    print(f"🌊 当前流路: {valve.get_flow_path()}")
     
     # 切换到试剂瓶1（1号位）
     print(f"\n🔌 切换到1号位: {valve.set_position(1)}")

unilabos/devices/virtual/virtual_stirrer.py

@@ -3,7 +3,6 @@ import logging
 import time as time_module
 from typing import Dict, Any
 
-from unilabos.registry.decorators import topic_config
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 class VirtualStirrer:
@@ -315,11 +314,9 @@ class VirtualStirrer:
     def min_speed(self) -> float:
         return self._min_speed
     
-    @property
-    @topic_config()
-    def device_info(self) -> Dict[str, Any]:
-        """设备状态快照信息 📊"""
-        return {
+    def get_device_info(self) -> Dict[str, Any]:
+        """获取设备状态信息 📊"""
+        info = {
             "device_id": self.device_id,
             "status": self.status,
             "operation_mode": self.operation_mode,
@@ -328,9 +325,12 @@ class VirtualStirrer:
             "is_stirring": self.is_stirring,
             "remaining_time": self.remaining_time,
             "max_speed": self._max_speed,
-            "min_speed": self._min_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

@@ -4,7 +4,6 @@ from enum import Enum
 from typing import Union, Optional
 import logging
 
-from unilabos.registry.decorators import topic_config
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
@@ -386,10 +385,8 @@ class VirtualTransferPump:
         """获取当前体积"""
         return self._current_volume
 
-    @property
-    @topic_config()
-    def remaining_capacity(self) -> float:
-        """剩余容量 (ml)"""
+    def get_remaining_capacity(self) -> float:
+        """获取剩余容量"""
         return self.max_volume - self._current_volume
 
     def is_empty(self) -> bool:

unilabos/devices/virtual/workbench.py

@@ -22,11 +22,10 @@ from threading import Lock, RLock
 from typing_extensions import TypedDict
 
 from unilabos.registry.decorators import (
-    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
+    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action
 )
-from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode, ROS2DeviceNode
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, ResourceTreeSet
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample
 
 
 # ============ TypedDict 返回类型定义 ============
@@ -291,126 +290,6 @@ class VirtualWorkbench:
         self._update_data_status(f"机械臂已释放 (完成: {task})")
         self.logger.info(f"机械臂已释放 (完成: {task})")
 
-    @action(
-        always_free=True, node_type=NodeType.MANUAL_CONFIRM, placeholder_keys={
-            "assignee_user_ids": "unilabos_manual_confirm"
-        }, goal_default={
-            "timeout_seconds": 3600,
-            "assignee_user_ids": []
-        }, feedback_interval=300,
-        handles=[
-            ActionInputHandle(key="target_device", data_type="device_id",
-                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="resource", data_type="resource",
-                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="mount_resource", data_type="resource",
-                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-
-            ActionInputHandle(key="collector_mass", data_type="collector_mass",
-                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="active_material", data_type="active_material",
-                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="capacity", data_type="capacity",
-                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="battery_system", data_type="battery_system",
-                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
-            # transfer使用
-            ActionOutputHandle(key="target_device", data_type="device_id",
-                               label="目标设备", data_key="target_device", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="resource", data_type="resource",
-                              label="待转移资源", data_key="resource.@flatten", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="mount_resource", data_type="resource",
-                              label="目标孔位", data_key="mount_resource.@flatten", data_source=DataSource.EXECUTOR),
-            # test使用
-            ActionOutputHandle(key="collector_mass", data_type="collector_mass",
-                              label="极流体质量", data_key="collector_mass", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="active_material", data_type="active_material",
-                              label="活性物质含量", data_key="active_material", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="capacity", data_type="capacity",
-                              label="克容量", data_key="capacity", data_source=DataSource.EXECUTOR),
-            ActionOutputHandle(key="battery_system", data_type="battery_system",
-                              label="电池体系", data_key="battery_system", data_source=DataSource.EXECUTOR),
-        ]
-    )
-    def manual_confirm(
-        self,
-        resource: List[ResourceSlot],
-        target_device: DeviceSlot,
-        mount_resource: List[ResourceSlot],
-        collector_mass: List[float],
-        active_material: List[float],
-        capacity: List[float],
-        battery_system: List[str],
-        timeout_seconds: int,
-        assignee_user_ids: list[str],
-        **kwargs
-    ) -> dict:
-        """
-        timeout_seconds: 超时时间（秒），默认3600秒
-        collector_mass: 极流体质量
-        active_material: 活性物质含量
-        capacity: 克容量（mAh/g）
-        battery_system: 电池体系
-        修改的结果无效，是只读的
-        """
-        resource = ResourceTreeSet.from_plr_resources(resource).dump()
-        mount_resource = ResourceTreeSet.from_plr_resources(mount_resource).dump()
-        kwargs.update(locals())
-        kwargs.pop("kwargs")
-        kwargs.pop("self")
-        return kwargs
-
-    @action(
-        description="转移物料",
-        handles=[
-            ActionInputHandle(key="target_device", data_type="device_id",
-                              label="目标设备", data_key="target_device", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="resource", data_type="resource",
-                               label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="mount_resource", data_type="resource",
-                               label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-        ]
-    )
-    async def transfer(self, resource: List[ResourceSlot], target_device: DeviceSlot, mount_resource: List[ResourceSlot]):
-        future = ROS2DeviceNode.run_async_func(self._ros_node.transfer_resource_to_another, True,
-            **{
-                "plr_resources": resource,
-                "target_device_id": target_device,
-                "target_resources": mount_resource,
-                "sites": [None] * len(mount_resource),
-            })
-        result = await future
-        return result
-
-
-    @action(
-        description="扣电测试启动",
-        handles=[
-            ActionInputHandle(key="resource", data_type="resource",
-                              label="待转移资源", data_key="resource", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="mount_resource", data_type="resource",
-                              label="目标孔位", data_key="mount_resource", data_source=DataSource.HANDLE),
-
-            ActionInputHandle(key="collector_mass", data_type="collector_mass",
-                              label="极流体质量", data_key="collector_mass", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="active_material", data_type="active_material",
-                              label="活性物质含量", data_key="active_material", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="capacity", data_type="capacity",
-                              label="克容量", data_key="capacity", data_source=DataSource.HANDLE),
-            ActionInputHandle(key="battery_system", data_type="battery_system",
-                              label="电池体系", data_key="battery_system", data_source=DataSource.HANDLE),
-        ]
-    )
-    async def test(
-        self, resource: List[ResourceSlot], mount_resource: List[ResourceSlot],  collector_mass: List[float], active_material: List[float], capacity: List[float], battery_system: list[str]
-    ):
-        print(resource)
-        print(mount_resource)
-        print(collector_mass)
-        print(active_material)
-        print(capacity)
-        print(battery_system)
-
     @action(
         auto_prefix=True,
         description="批量准备物料 - 虚拟起始节点, 生成A1-A5物料, 输出5个handle供后续节点使用",

unilabos/devices/workstation/README.md

@@ -1,5 +1,9 @@
 # 工作站抽象基类物料系统架构说明
 
+## 设计理念
+
+基于用户需求"请你帮我系统思考一下，工作站抽象基类的物料系统基类该如何构建"，我们最终确定了一个**PyLabRobot Deck为中心**的简化架构。
+
 ### 核心原则
 
 1. **PyLabRobot为物料管理核心**：使用PyLabRobot的Deck系统作为物料管理的基础，利用其成熟的Resource体系

unilabos/devices/workstation/bioyond_studio/bioyond_cell/20251229_多订单返回说明.md

@@ -1,113 +0,0 @@
-# Bioyond Cell 工作站 - 多订单返回示例
-
-本文档说明了 `create_orders` 函数如何收集并返回所有订单的完成报文。
-
-## 问题描述
-
-之前的实现只会等待并返回第一个订单的完成报文，如果有多个订单（例如从 Excel 解析出 3 个订单），只能得到第一个订单的推送信息。
-
-## 解决方案
-
-修改后的 `create_orders` 函数现在会：
-
-1. **提取所有 orderCode**：从 LIMS 接口返回的 `data` 列表中提取所有订单编号
-2. **逐个等待完成**：遍历所有 orderCode，调用 `wait_for_order_finish` 等待每个订单完成
-3. **收集所有报文**：将每个订单的完成报文存入 `all_reports` 列表
-4. **统一返回**：返回包含所有订单报文的 JSON 格式数据
-
-## 返回格式
-
-```json
-{
-    "status": "all_completed",
-    "total_orders": 3,
-    "reports": [
-        {
-            "token": "",
-            "request_time": "2025-12-24T15:32:09.2148671+08:00",
-            "data": {
-                "orderId": "3a1e614d-a082-c44a-60be-68647a35e6f1",
-                "orderCode": "BSO2025122400024",
-                "orderName": "DP20251224001",
-                "status": "30",
-                "workflowStatus": "completed",
-                "usedMaterials": [...]
-            }
-        },
-        {
-            "token": "",
-            "request_time": "2025-12-24T15:32:09.9999039+08:00",
-            "data": {
-                "orderId": "3a1e614d-a0a2-f7a9-9360-610021c9479d",
-                "orderCode": "BSO2025122400025",
-                "orderName": "DP20251224002",
-                "status": "30",
-                "workflowStatus": "completed",
-                "usedMaterials": [...]
-            }
-        },
-        {
-            "token": "",
-            "request_time": "2025-12-24T15:34:00.4139986+08:00",
-            "data": {
-                "orderId": "3a1e614d-a0cd-81ca-9f7f-2f4e93af01cd",
-                "orderCode": "BSO2025122400026",
-                "orderName": "DP20251224003",
-                "status": "30",
-                "workflowStatus": "completed",
-                "usedMaterials": [...]
-            }
-        }
-    ],
-    "original_response": {...}
-}
-```
-
-## 使用示例
-
-```python
-# 调用 create_orders
-result = workstation.create_orders("20251224.xlsx")
-
-# 访问返回数据
-print(f"总订单数: {result['total_orders']}")
-print(f"状态: {result['status']}")
-
-# 遍历所有订单的报文
-for i, report in enumerate(result['reports'], 1):
-    order_data = report.get('data', {})
-    print(f"\n订单 {i}:")
-    print(f"  orderCode: {order_data.get('orderCode')}")
-    print(f"  orderName: {order_data.get('orderName')}")
-    print(f"  status: {order_data.get('status')}")
-    print(f"  使用物料数: {len(order_data.get('usedMaterials', []))}")
-```
-
-## 控制台输出示例
-
-```
-[create_orders] 即将提交订单数量: 3
-[create_orders] 接口返回: {...}
-[create_orders] 等待 3 个订单完成: ['BSO2025122400024', 'BSO2025122400025', 'BSO2025122400026']
-[create_orders] 正在等待第 1/3 个订单: BSO2025122400024
-[create_orders] ✓ 订单 BSO2025122400024 完成
-[create_orders] 正在等待第 2/3 个订单: BSO2025122400025
-[create_orders] ✓ 订单 BSO2025122400025 完成
-[create_orders] 正在等待第 3/3 个订单: BSO2025122400026
-[create_orders] ✓ 订单 BSO2025122400026 完成
-[create_orders] 所有订单已完成，共收集 3 个报文
-实验记录本========================create_orders========================
-返回报文数量: 3
-报文 1: orderCode=BSO2025122400024, status=30
-报文 2: orderCode=BSO2025122400025, status=30
-报文 3: orderCode=BSO2025122400026, status=30
-========================
-```
-
-## 关键改进
-
-1. ✅ **等待所有订单**：不再只等待第一个订单，而是遍历所有 orderCode
-2. ✅ **收集完整报文**：每个订单的完整推送报文都被保存在 `reports` 数组中
-3. ✅ **详细日志**：清晰显示正在等待哪个订单，以及完成情况
-4. ✅ **错误处理**：即使某个订单失败，也会记录其状态信息
-5. ✅ **统一格式**：返回的 JSON 格式便于后续处理和分析

unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_JSON配置迁移经验.md

@@ -1,204 +0,0 @@
-# BioyondCellWorkstation JSON 配置迁移经验总结
-
-**日期**: 2026-01-13  
-**目的**: 从 `config.py` 迁移到 JSON 配置文件
-
----
-
-## 问题背景
-
-原系统通过 `config.py` 管理配置，导致：
-1. HTTP 服务重复启动（父类 `BioyondWorkstation` 和子类都启动）
-2. 配置分散在代码中，不便于管理
-3. 无法通过 JSON 统一配置所有参数
-
----
-
-## 解决方案：嵌套配置结构
-
-### JSON 结构设计
-
-**正确示例** (嵌套在 `config` 中):
-```json
-{
-  "nodes": [{
-    "id": "bioyond_cell_workstation",
-    "config": {
-      "deck": {...},
-      "protocol_type": [],
-      "bioyond_config": {
-        "api_host": "http://172.16.11.219:44388",
-        "api_key": "8A819E5C",
-        "timeout": 30,
-        "HTTP_host": "172.16.11.206",
-        "HTTP_port": 8080,
-        "debug_mode": false,
-        "material_type_mappings": {...},
-        "warehouse_mapping": {...},
-        "solid_liquid_mappings": {...}
-      }
-    },
-    "data": {}
-  }]
-}
-```
-
-**关键点**：
-- ✅ `bioyond_config` 放在 `config` 中（会传递到 `__init__`）
-- ❌ **不要**放在 `data` 中（`data` 是运行时状态，不会传递）
-
----
-
-## Python 代码适配
-
-### 1. 修改 `BioyondCellWorkstation.__init__` 签名
-
-**文件**: `bioyond_cell_workstation.py`
-
-```python
-def __init__(self, bioyond_config: dict = None, deck=None, protocol_type=None, **kwargs):
-    """
-    Args:
-        bioyond_config: 从 JSON 加载的配置字典
-        deck: Deck 配置
-        protocol_type: 协议类型
-    """
-    # 验证配置
-    if bioyond_config is None:
-        raise ValueError("需要 bioyond_config 参数")
-    
-    # 保存配置
-    self.bioyond_config = bioyond_config
-    
-    # 设置 HTTP 服务去重标志
-    self.bioyond_config["_disable_auto_http_service"] = True
-    
-    # 调用父类
-    super().__init__(bioyond_config=self.bioyond_config, deck=deck, **kwargs)
-```
-
-### 2. 替换全局变量引用
-
-**修改前**（使用全局变量）:
-```python
-from config import MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING
-
-def create_sample(self, board_type, ...):
-    carrier_type_id = MATERIAL_TYPE_MAPPINGS[board_type][1]
-    location_id = WAREHOUSE_MAPPING[warehouse_name]["site_uuids"][location_code]
-```
-
-**修改后**（从配置读取）:
-```python
-def create_sample(self, board_type, ...):
-    carrier_type_id = self.bioyond_config['material_type_mappings'][board_type][1]
-    location_id = self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"][location_code]
-```
-
-### 3. 修复父类配置访问
-
-在 `station.py` 中安全访问配置默认值：
-
-```python
-# 修改前（会 KeyError）
-self._http_service_config = {
-    "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG["http_service_host"])
-}
-
-# 修改后（安全访问）
-self._http_service_config = {
-    "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG.get("http_service_host", ""))
-}
-```
-
----
-
-## 常见陷阱
-
-### ❌ 错误1：将配置放在 `data` 字段
-```json
-"config": {"deck": {...}},
-"data": {"bioyond_config": {...}}  // ❌ 不会传递到 __init__
-```
-
-### ❌ 错误2：扁平化配置（已废弃方案）
-虽然扁平化也能工作，但不推荐：
-```json
-"config": {
-  "deck": {...},
-  "api_host": "...",     // ❌ 不够清晰
-  "api_key": "...",
-  "HTTP_host": "..."
-}
-```
-
-### ❌ 错误3：忘记替换全局变量引用
-代码中直接使用 `MATERIAL_TYPE_MAPPINGS` 等全局变量会导致 `NameError`。
-
----
-
-## 云端同步注意事项
-
-使用 `--upload_registry` 时，云端配置可能覆盖本地配置：
-- 首次上传时确保 JSON 完整
-- 或使用新的 `ak/sk` 避免旧配置干扰
-- 调试时可暂时移除 `--upload_registry` 参数
-
----
-
-## 验证清单
-
-启动成功后应看到：
-```
-✅ 从 JSON 配置加载 bioyond_config 成功
-   API Host: http://...
-   HTTP Service: ...
-✅ BioyondCellWorkstation 初始化完成
-Loaded ResourceTreeSet with ... nodes
-```
-
-运行时不应出现：
-- ❌ `NameError: name 'MATERIAL_TYPE_MAPPINGS' is not defined`
-- ❌ `KeyError: 'http_service_host'`
-- ❌ `bioyond_config 缺少必需参数`
-
----
-
-## 调试经验
-
-1. **添加调试日志**查看参数传递链路：
-   - `graphio.py`: JSON 加载后的 config 内容
-   - `initialize_device.py`: `device_config.res_content.config` 的键
-   - `bioyond_cell_workstation.py`: `__init__` 接收到的参数
-
-2. **config vs data 区别**：
-   - `config`: 初始化参数，传递给 `__init__`
-   - `data`: 运行时状态，不传递给 `__init__`
-
-3. **参数名必须匹配**：
-   - JSON 中的键名必须与 `__init__` 参数名完全一致
-
-4. **调试代码清理**：完成后记得删除调试日志（🔍 DEBUG 标记）
-
----
-
-## 修改文件清单
-
-| 文件 | 修改内容 |
-|------|----------|
-| `yibin_electrolyte_config.json` | 创建嵌套 `config.bioyond_config` 结构 |
-| `bioyond_cell_workstation.py` | 修改 `__init__` 接收 `bioyond_config`，替换所有全局变量引用 |
-| `station.py` | 安全访问 `HTTP_SERVICE_CONFIG` 默认值 |
-
----
-
-## 参考代码位置
-
-- JSON 配置示例: `yibin_electrolyte_config.json` L12-L353
-- `__init__` 实现: `bioyond_cell_workstation.py` L39-L94
-- 全局变量替换示例: `bioyond_cell_workstation.py` L2005, L1863, L1966
-- HTTP 服务配置: `station.py` L629-L634
-
----
-
-**总结**: 使用嵌套结构将所有配置放在 `config.bioyond_config` 中，修改 `__init__` 直接接收该参数，并替换所有全局变量引用为 `self.bioyond_config` 访问。

unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_配置迁移修改总结.md

@@ -1,312 +0,0 @@
-# BioyondCell 配置迁移修改总结
-
-**日期**: 2026-01-13  
-**目标**: 从 `config.py` 完全迁移到 JSON 配置，消除所有全局变量依赖
-
----
-
-## 📋 修改概览
-
-本次修改完成了 BioyondCell 模块从 Python 配置文件到 JSON 配置的完整迁移，并清理了所有对 `config.py` 全局变量的依赖。
-
-### 核心成果
-
-- ✅ 完全移除对 `config.py` 的导入依赖
-- ✅ 使用嵌套 JSON 结构 `config.bioyond_config`
-- ✅ 修复 7 处 `bioyond_cell_workstation.py` 中的全局变量引用
-- ✅ 修复 3 处其他文件中的全局变量引用
-- ✅ HTTP 服务去重机制完善
-- ✅ 系统成功启动并正常运行
-
----
-
-## 🔧 修改文件清单
-
-### 1. JSON 配置文件
-
-**文件**: `yibin_electrolyte_config.json`
-
-**修改**:
-- 采用嵌套结构将所有配置放在 `config.bioyond_config` 中
-- 包含：`api_host`, `api_key`, `HTTP_host`, `HTTP_port`, `material_type_mappings`, `warehouse_mapping`, `solid_liquid_mappings` 等
-
-**示例结构**:
-```json
-{
-  "nodes": [{
-    "id": "bioyond_cell_workstation",
-    "config": {
-      "deck": {...},
-      "protocol_type": [],
-      "bioyond_config": {
-        "api_host": "http://172.16.11.219:44388",
-        "api_key": "8A819E5C",
-        "HTTP_host": "172.16.11.206",
-        "HTTP_port": 8080,
-        "material_type_mappings": {...},
-        "warehouse_mapping": {...},
-        "solid_liquid_mappings": {...}
-      }
-    }
-  }]
-}
-```
-
----
-
-### 2. bioyond_cell_workstation.py
-
-**位置**: `unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`
-
-#### 修改 A: `__init__` 方法签名 (L39-99)
-
-**修改前**:
-```python
-def __init__(self, deck=None, protocol_type=None, **kwargs):
-    # 从 kwargs 收集配置字段
-    self.bioyond_config = {}
-    for field in bioyond_field_names:
-        if field in kwargs:
-            self.bioyond_config[field] = kwargs.pop(field)
-```
-
-**修改后**:
-```python
-def __init__(self, bioyond_config: dict = None, deck=None, protocol_type=None, **kwargs):
-    """直接接收 bioyond_config 参数"""
-    if bioyond_config is None:
-        raise ValueError("需要 bioyond_config 参数")
-    
-    self.bioyond_config = bioyond_config
-    
-    # 设置 HTTP 服务去重标志
-    self.bioyond_config["_disable_auto_http_service"] = True
-    
-    super().__init__(bioyond_config=self.bioyond_config, deck=deck, **kwargs)
-```
-
-#### 修改 B: 替换全局变量引用 (7 处)
-
-| 位置 | 原代码 | 修改后 |
-|------|--------|--------|
-| L2005 | `MATERIAL_TYPE_MAPPINGS[board_type][1]` | `self.bioyond_config['material_type_mappings'][board_type][1]` |
-| L2006 | `MATERIAL_TYPE_MAPPINGS[bottle_type][1]` | `self.bioyond_config['material_type_mappings'][bottle_type][1]` |
-| L2009 | `WAREHOUSE_MAPPING` | `self.bioyond_config['warehouse_mapping']` |
-| L2013 | `WAREHOUSE_MAPPING[warehouse_name]` | `self.bioyond_config['warehouse_mapping'][warehouse_name]` |
-| L2017 | `WAREHOUSE_MAPPING[warehouse_name]["site_uuids"]` | `self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"]` |
-| L1863 | `SOLID_LIQUID_MAPPINGS.get(material_name)` | `self.bioyond_config.get('solid_liquid_mappings', {}).get(material_name)` |
-| L1966, L1976 | `MATERIAL_TYPE_MAPPINGS.items()` | `self.bioyond_config['material_type_mappings'].items()` |
-
----
-
-### 3. station.py
-
-**位置**: `unilabos/devices/workstation/bioyond_studio/station.py`
-
-#### 修改 A: 删除 config 导入 (L26-28)
-
-**修改前**:
-```python
-from unilabos.devices.workstation.bioyond_studio.config import (
-    API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING, HTTP_SERVICE_CONFIG
-)
-```
-
-**修改后**:
-```python
-# 已删除此导入
-```
-
-#### 修改 B: `_create_communication_module` 方法 (L691-702)
-
-**修改前**:
-```python
-def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None:
-    default_config = {
-        **API_CONFIG,
-        "workflow_mappings": WORKFLOW_MAPPINGS,
-        "material_type_mappings": MATERIAL_TYPE_MAPPINGS,
-        "warehouse_mapping": WAREHOUSE_MAPPING
-    }
-    if config:
-        self.bioyond_config = {**default_config, **config}
-    else:
-        self.bioyond_config = default_config
-```
-
-**修改后**:
-```python
-def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None:
-    """创建Bioyond通信模块"""
-    # 使用传入的 config 参数（来自 bioyond_config）
-    # 不再依赖全局变量 API_CONFIG 等
-    if config:
-        self.bioyond_config = config
-    else:
-        # 如果没有传入配置，创建空配置（用于测试或兼容性）
-        self.bioyond_config = {}
-    
-    self.hardware_interface = BioyondV1RPC(self.bioyond_config)
-```
-
-#### 修改 C: HTTP 服务配置 (L627-632)
-
-**修改前**:
-```python
-self._http_service_config = {
-    "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG.get("http_service_host", "")),
-    "port": bioyond_config.get("http_service_port", HTTP_SERVICE_CONFIG.get("http_service_port", 0))
-}
-```
-
-**修改后**:
-```python
-self._http_service_config = {
-    "host": bioyond_config.get("http_service_host", bioyond_config.get("HTTP_host", "")),
-    "port": bioyond_config.get("http_service_port", bioyond_config.get("HTTP_port", 0))
-}
-```
-
----
-
-### 4. bioyond_rpc.py
-
-**位置**: `unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py`
-
-#### 修改 A: 删除 config 导入 (L12)
-
-**修改前**:
-```python
-from unilabos.devices.workstation.bioyond_studio.config import LOCATION_MAPPING
-```
-
-**修改后**:
-```python
-# 已删除此导入
-```
-
-#### 修改 B: `material_outbound` 方法 (L278-280)
-
-**修改前**:
-```python
-def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
-    """指定库位出库物料（通过库位名称）"""
-    location_id = LOCATION_MAPPING.get(location_name, location_name)
-```
-
-**修改后**:
-```python
-def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
-    """指定库位出库物料（通过库位名称）"""
-    # location_name 参数实际上应该直接是 location_id (UUID)
-    location_id = location_name
-```
-
-**说明**: `LOCATION_MAPPING` 在 `config-0113.py` 中本来就是空字典 `{}`，所以直接使用 `location_name` 逻辑等价。
-
----
-
-## 🎯 关键设计决策
-
-### 1. 嵌套 vs 扁平配置
-
-**选择**: 嵌套结构 `config.bioyond_config`
-
-**理由**:
-- ✅ 语义清晰，配置分组明确
-- ✅ 参数传递直观，直接对应 `__init__` 参数
-- ✅ 易于维护，不需要硬编码字段列表
-- ✅ 符合 UniLab 设计模式
-
-### 2. HTTP 服务去重
-
-**实现**: 子类设置 `_disable_auto_http_service` 标志
-
-```python
-# bioyond_cell_workstation.py
-self.bioyond_config["_disable_auto_http_service"] = True
-
-# station.py (post_init)
-if self.bioyond_config.get("_disable_auto_http_service"):
-    logger.info("子类已自行管理HTTP服务，跳过自动启动")
-    return
-```
-
-### 3. 全局变量替换策略
-
-**原则**: 所有配置从 `self.bioyond_config` 获取
-
-**模式**:
-```python
-# 修改前
-from config import MATERIAL_TYPE_MAPPINGS
-carrier_type_id = MATERIAL_TYPE_MAPPINGS[board_type][1]
-
-# 修改后
-carrier_type_id = self.bioyond_config['material_type_mappings'][board_type][1]
-```
-
----
-
-## ✅ 验证结果
-
-### 启动成功日志
-```
-✅ 从 JSON 配置加载 bioyond_config 成功
-   API Host: http://172.16.11.219:44388
-   HTTP Service: 172.16.11.206:8080
-🔧 已设置 _disable_auto_http_service 标志，防止 HTTP 服务重复启动
-✅ BioyondCellWorkstation 初始化完成
-Loaded ResourceTreeSet with 1 trees, 1785 total nodes
-```
-
-### 功能验证
-- ✅ 订单创建 (`create_orders_v2`)
-- ✅ 质量比计算
-- ✅ 物料转移 (`transfer_3_to_2_to_1`)
-- ✅ HTTP 报送接收 (step_finish, sample_finish, order_finish)
-- ✅ 等待机制 (`wait_for_order_finish`)
-- ✅ 仓库 UUID 映射
-- ✅ 物料类型映射
-
----
-
-## 📚 相关文档
-
-- **配置迁移经验**: `2026-01-13_JSON配置迁移经验.md`
-- **任务清单**: `C:\Users\AndyXie\.gemini\antigravity\brain\...\task.md`
-- **实施计划**: `C:\Users\AndyXie\.gemini\antigravity\brain\...\implementation_plan.md`
-
----
-
-## ⚠️ 注意事项
-
-### 其他工作站模块
-
-以下文件仍在使用 `config.py` 全局变量（未包含在本次修改中）:
-- `reaction_station.py` - 使用 `API_CONFIG`
-- `experiment.py` - 使用 `API_CONFIG`, `WORKFLOW_MAPPINGS`, `MATERIAL_TYPE_MAPPINGS`
-- `dispensing_station.py` - 使用 `API_CONFIG`, `WAREHOUSE_MAPPING`
-- `station.py` L176, L177, L529, L530 - 动态导入 `WAREHOUSE_MAPPING`
-
-**建议**: 后续可以统一迁移这些模块到 JSON 配置。
-
-### config.py 文件
-
-`config.py` 文件已恢复但**不再被 bioyond_cell 使用**。可以：
-- 保留作为其他模块的参考
-- 或者完全删除（如果其他模块也迁移完成）
-
----
-
-## 🚀 下一步建议
-
-1. **清理调试代码** ✅ (已完成)
-2. **提交代码到 Git**
-3. **迁移其他工作站模块** (可选)
-4. **更新文档和启动脚本**
-
----
-
-**修改完成日期**: 2026-01-13  
-**系统状态**: ✅ 稳定运行

unilabos/devices/workstation/bioyond_studio/bioyond_cell/批量出库模板使用说明.md

@@ -1,157 +0,0 @@
-# 批量出库 Excel 模板使用说明
-
-**文件**: `outbound_template.xlsx`  
-**用途**: 配合 `auto_batch_outbound_from_xlsx()` 方法进行批量出库操作  
-**API 端点**: `/api/lims/storage/auto-batch-out-bound`
-
----
-
-## 📋 Excel 列说明
-
-| 列名 | 说明 | 示例 | 必填 |
-|------|------|------|------|
-| `locationId` | **库位 ID（UUID）** | `3a19da43-57b5-294f-d663-154a1cc32270` | ✅ 是 |
-| `warehouseId` | **仓库 ID 或名称** | `配液站内试剂仓库` | ✅ 是 |
-| `quantity` | **出库数量** | `1.0`, `2.0` | ✅ 是 |
-| `x` | **X 坐标（库位横向位置）** | `1`, `2`, `3` | ✅ 是 |
-| `y` | **Y 坐标（库位纵向位置）** | `1`, `2`, `3` | ✅ 是 |
-| `z` | **Z 坐标（库位层数/高度）** | `1`, `2`, `3` | ✅ 是 |
-| `备注说明` | 可选备注信息 | `配液站内试剂仓库-A01` | ❌ 否 |
-
-### 📐 坐标说明
-
-**x, y, z** 是库位在仓库内的**三维坐标**：
-
-```
-仓库（例如 WH4）
-├── Z=1（第1层/加样头面）
-│   ├── X=1, Y=1（位置 A）
-│   ├── X=2, Y=1（位置 B）
-│   ├── X=3, Y=1（位置 C）
-│   └── ...
-│
-└── Z=2（第2层/原液瓶面）
-    ├── X=1, Y=1（位置 A）
-    ├── X=2, Y=1（位置 B）
-    └── ...
-```
-
-- **warehouseId**: 指定哪个仓库（WH3, WH4, 配液站等）
-- **x, y, z**: 在该仓库内的三维坐标
-- **locationId**: 该坐标位置的唯一 UUID
-
-### 🎯 起点与终点
-
-**重要说明**：批量出库模板**只规定了出库的"起点"**（从哪里取物料），**没有指定"终点"**（放到哪里）。
-
-```
-出库流程：
-起点（Excel 指定） → ？终点（LIMS/工作流决定）
-    ↓
-locationId, x, y, z    → 由 LIMS 系统或当前工作流自动分配
-```
-
-**终点由以下方式确定：**
-- **LIMS 系统自动分配**：根据当前任务自动规划目标位置
-- **工作流预定义**：在创建出库任务时已绑定目标位置
-- **暂存区**：默认放到出库暂存区，等待下一步操作
-
-💡 **对比**：上料操作（`auto_feeding4to3`）则有 `targetWH` 参数可以指定目标仓库
-
----
-
-## 🔍 如何获取 UUID？
-
-### 方法 1：从配置文件获取
-
-参考 `yibin_electrolyte_config.json` 中的 `warehouse_mapping`：
-
-```json
-{
-  "warehouse_mapping": {
-    "配液站内试剂仓库": {
-      "site_uuids": {
-        "A01": "3a19da43-57b5-294f-d663-154a1cc32270",
-        "B01": "3a19da43-57b5-7394-5f49-54efe2c9bef2",
-        "C01": "3a19da43-57b5-5e75-552f-8dbd0ad1075f"
-      }
-    },
-    "手动堆栈": {
-      "site_uuids": {
-        "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
-        "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe"
-      }
-    }
-  }
-}
-```
-
-### 方法 2：通过 API 查询
-
-```python
-material_info = hardware_interface.material_id_query(workflow_id)
-locations = material_info.get("locations", [])
-```
-
----
-
-## 📝 填写示例
-
-### 示例 1：从配液站内试剂仓库出库
-
-| locationId | warehouseId | quantity | x | y | z | 备注说明 |
-|------------|-------------|----------|---|---|---|----------|
-| `3a19da43-57b5-294f-d663-154a1cc32270` | 配液站内试剂仓库 | 1 | 1 | 1 | 1 | A01 位置 |
-| `3a19da43-57b5-7394-5f49-54efe2c9bef2` | 配液站内试剂仓库 | 2 | 2 | 1 | 1 | B01 位置 |
-
-### 示例 2：从手动堆栈出库
-
-| locationId | warehouseId | quantity | x | y | z | 备注说明 |
-|------------|-------------|----------|---|---|---|----------|
-| `3a19deae-2c7a-36f5-5e41-02c5b66feaea` | 手动堆栈 | 1 | 1 | 1 | 1 | A01 |
-| `3a19deae-2c7a-dc6d-c41e-ef285d946cfe` | 手动堆栈 | 1 | 1 | 2 | 1 | A02 |
-
----
-
-## 💻 使用方法
-
-```python
-from bioyond_cell_workstation import BioyondCellWorkstation
-
-# 初始化工作站
-workstation = BioyondCellWorkstation(config=config, deck=deck)
-
-# 调用批量出库方法
-result = workstation.auto_batch_outbound_from_xlsx(
-    xlsx_path="outbound_template.xlsx"
-)
-```
-
----
-
-## ⚠️ 注意事项
-
-1. **locationId 必须是有效的 UUID**，不能使用库位名称
-2. **x, y, z 坐标必须与 locationId 对应**，表示该库位在仓库内的位置
-3. **quantity 必须是数字**，可以是整数或浮点数
-4. Excel 文件必须包含表头行
-5. 空行会被自动跳过
-6. 确保 UUID 与实际库位对应，否则 API 会报错
-
----
-
-## 📚 相关文件
-
-- **配置文件**: `yibin_electrolyte_config.json`
-- **Python 代码**: `bioyond_cell_workstation.py` (L630-695)
-- **生成脚本**: `create_outbound_template.py`
-- **上料模板**: `material_template.xlsx`
-
----
-
-## 🔄 重新生成模板
-
-```bash
-conda activate newunilab
-python create_outbound_template.py
-```

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -9,7 +9,7 @@ from datetime import datetime, timezone
 from unilabos.device_comms.rpc import BaseRequest
 from typing import Optional, List, Dict, Any
 import json
-
+from unilabos.devices.workstation.bioyond_studio.config import LOCATION_MAPPING
 
 
 class SimpleLogger:
@@ -49,14 +49,6 @@ class BioyondV1RPC(BaseRequest):
         self.config = config
         self.api_key = config["api_key"]
         self.host = config["api_host"]
-
-        # 初始化 location_mapping
-        # 直接从 warehouse_mapping 构建，确保数据源所谓的单一和结构化
-        self.location_mapping = {}
-        warehouse_mapping = self.config.get("warehouse_mapping", {})
-        for warehouse_name, warehouse_config in warehouse_mapping.items():
-            if "site_uuids" in warehouse_config:
-                self.location_mapping.update(warehouse_config["site_uuids"])
         self._logger = SimpleLogger()
         self.material_cache = {}
         self._load_material_cache()
@@ -184,40 +176,7 @@ class BioyondV1RPC(BaseRequest):
             return {}
 
         print(f"add material data: {response['data']}")
-
-        # 自动更新缓存
-        data = response.get("data", {})
-        if data:
-            if isinstance(data, str):
-                # 如果返回的是字符串，通常是ID
-                mat_id = data
-                name = params.get("name")
-            else:
-                # 如果返回的是字典，尝试获取name和id
-                name = data.get("name") or params.get("name")
-                mat_id = data.get("id")
-
-            if name and mat_id:
-                self.material_cache[name] = mat_id
-                print(f"已自动更新缓存: {name} -> {mat_id}")
-
-            # 处理返回数据中的 details (如果有)
-            # 有些 API 返回结构可能直接包含 details，或者在 data 字段中
-            details = data.get("details", []) if isinstance(data, dict) else []
-            if not details and isinstance(data, dict):
-                 details = data.get("detail", [])
-
-            if details:
-                for detail in details:
-                    d_name = detail.get("name")
-                    # 尝试从不同字段获取 ID
-                    d_id = detail.get("id") or detail.get("detailMaterialId")
-
-                    if d_name and d_id:
-                        self.material_cache[d_name] = d_id
-                        print(f"已自动更新 detail 缓存: {d_name} -> {d_id}")
-
-        return data
+        return response.get("data", {})
 
     def query_matial_type_id(self, data) -> list:
         """查找物料typeid"""
@@ -244,7 +203,7 @@ class BioyondV1RPC(BaseRequest):
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
-                "data": 0,
+                "data": {},
             })
         if not response or response['code'] != 1:
             return []
@@ -314,19 +273,11 @@ class BioyondV1RPC(BaseRequest):
 
         if not response or response['code'] != 1:
             return {}
-
-        # 自动更新缓存 - 移除被删除的物料
-        for name, mid in list(self.material_cache.items()):
-            if mid == material_id:
-                del self.material_cache[name]
-                print(f"已从缓存移除物料: {name}")
-                break
-
         return response.get("data", {})
 
     def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
         """指定库位出库物料（通过库位名称）"""
-        location_id = self.location_mapping.get(location_name, location_name)
+        location_id = LOCATION_MAPPING.get(location_name, location_name)
 
         params = {
             "materialId": material_id,
@@ -1152,10 +1103,6 @@ class BioyondV1RPC(BaseRequest):
                     for detail_material in detail_materials:
                         detail_name = detail_material.get("name")
                         detail_id = detail_material.get("detailMaterialId")
-                        if not detail_id:
-                            # 尝试其他可能的字段
-                            detail_id = detail_material.get("id")
-
                         if detail_name and detail_id:
                             self.material_cache[detail_name] = detail_id
                             print(f"加载detail材料: {detail_name} -> ID: {detail_id}")
@@ -1176,14 +1123,6 @@ class BioyondV1RPC(BaseRequest):
             print(f"从缓存找到材料: {material_name_or_id} -> ID: {material_id}")
             return material_id
 
-        # 如果缓存中没有，尝试刷新缓存
-        print(f"缓存中未找到材料 '{material_name_or_id}'，尝试刷新缓存...")
-        self.refresh_material_cache()
-        if material_name_or_id in self.material_cache:
-            material_id = self.material_cache[material_name_or_id]
-            print(f"刷新缓存后找到材料: {material_name_or_id} -> ID: {material_id}")
-            return material_id
-
         print(f"警告: 未在缓存中找到材料名称 '{material_name_or_id}'，将使用原值")
         return material_name_or_id
 

unilabos/devices/workstation/bioyond_studio/config.py

@@ -0,0 +1,142 @@
+# config.py
+"""
+配置文件 - 包含所有配置信息和映射关系
+"""
+
+# API配置
+API_CONFIG = {
+    "api_key": "",
+    "api_host": ""
+}
+
+# 工作流映射配置
+WORKFLOW_MAPPINGS = {
+    "reactor_taken_out": "",
+    "reactor_taken_in": "",
+    "Solid_feeding_vials": "",
+    "Liquid_feeding_vials(non-titration)": "",
+    "Liquid_feeding_solvents": "",
+    "Liquid_feeding(titration)": "",
+    "liquid_feeding_beaker": "",
+    "Drip_back": "",
+}
+
+# 工作流名称到DisplaySectionName的映射
+WORKFLOW_TO_SECTION_MAP = {
+    'reactor_taken_in': '反应器放入',
+    'liquid_feeding_beaker': '液体投料-烧杯',
+    'Liquid_feeding_vials(non-titration)': '液体投料-小瓶（非滴定）',
+    'Liquid_feeding_solvents': '液体投料-溶剂',
+    'Solid_feeding_vials': '固体投料-小瓶',
+    'Liquid_feeding(titration)': '液体投料-滴定',
+    'reactor_taken_out': '反应器取出'
+}
+
+# 库位映射配置
+WAREHOUSE_MAPPING = {
+    "粉末堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            # 样品板
+            "A1": "3a14198e-6929-31f0-8a22-0f98f72260df",
+            "A2": "3a14198e-6929-4379-affa-9a2935c17f99",
+            "A3": "3a14198e-6929-56da-9a1c-7f5fbd4ae8af",
+            "A4": "3a14198e-6929-5e99-2b79-80720f7cfb54",
+            "B1": "3a14198e-6929-f525-9a1b-1857552b28ee",
+            "B2": "3a14198e-6929-bf98-0fd5-26e1d68bf62d",
+            "B3": "3a14198e-6929-2d86-a468-602175a2b5aa",
+            "B4": "3a14198e-6929-1a98-ae57-e97660c489ad",
+            # 分装板
+            "C1": "3a14198e-6929-46fe-841e-03dd753f1e4a",
+            "C2": "3a14198e-6929-1bc9-a9bd-3b7ca66e7f95",
+            "C3": "3a14198e-6929-72ac-32ce-9b50245682b8",
+            "C4": "3a14198e-6929-3bd8-e6c7-4a9fd93be118",
+            "D1": "3a14198e-6929-8a0b-b686-6f4a2955c4e2",
+            "D2": "3a14198e-6929-dde1-fc78-34a84b71afdf",
+            "D3": "3a14198e-6929-a0ec-5f15-c0f9f339f963",
+            "D4": "3a14198e-6929-7ac8-915a-fea51cb2e884"
+        }
+    },
+    "溶液堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A1": "3a14198e-d724-e036-afdc-2ae39a7f3383",
+            "A2": "3a14198e-d724-afa4-fc82-0ac8a9016791",
+            "A3": "3a14198e-d724-ca48-bb9e-7e85751e55b6",
+            "A4": "3a14198e-d724-df6d-5e32-5483b3cab583",
+            "B1": "3a14198e-d724-d818-6d4f-5725191a24b5",
+            "B2": "3a14198e-d724-be8a-5e0b-012675e195c6",
+            "B3": "3a14198e-d724-cc1e-5c2c-228a130f40a8",
+            "B4": "3a14198e-d724-1e28-c885-574c3df468d0",
+            "C1": "3a14198e-d724-b5bb-adf3-4c5a0da6fb31",
+            "C2": "3a14198e-d724-ab4e-48cb-817c3c146707",
+            "C3": "3a14198e-d724-7f18-1853-39d0c62e1d33",
+            "C4": "3a14198e-d724-28a2-a760-baa896f46b66",
+            "D1": "3a14198e-d724-d378-d266-2508a224a19f",
+            "D2": "3a14198e-d724-f56e-468b-0110a8feb36a",
+            "D3": "3a14198e-d724-0cf1-dea9-a1f40fe7e13c",
+            "D4": "3a14198e-d724-0ddd-9654-f9352a421de9"
+        }
+    },
+    "试剂堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A1": "3a14198c-c2cf-8b40-af28-b467808f1c36",
+            "A2": "3a14198c-c2d0-f3e7-871a-e470d144296f",
+            "A3": "3a14198c-c2d0-dc7d-b8d0-e1d88cee3094",
+            "A4": "3a14198c-c2d0-2070-efc8-44e245f10c6f",
+            "B1": "3a14198c-c2d0-354f-39ad-642e1a72fcb8",
+            "B2": "3a14198c-c2d0-1559-105d-0ea30682cab4",
+            "B3": "3a14198c-c2d0-725e-523d-34c037ac2440",
+            "B4": "3a14198c-c2d0-efce-0939-69ca5a7dfd39"
+        }
+    }
+}
+
+# 物料类型配置
+MATERIAL_TYPE_MAPPINGS = {
+    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
+    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
+    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
+    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
+    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
+    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
+    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+}
+
+# 步骤参数配置（各工作流的步骤UUID）
+WORKFLOW_STEP_IDS = {
+    "reactor_taken_in": {
+        "config": ""
+    },
+    "liquid_feeding_beaker": {
+        "liquid": "",
+        "observe": ""
+    },
+    "liquid_feeding_vials_non_titration": {
+        "liquid": "",
+        "observe": ""
+    },
+    "liquid_feeding_solvents": {
+        "liquid": "",
+        "observe": ""
+    },
+    "solid_feeding_vials": {
+        "feeding": "",
+        "observe": ""
+    },
+    "liquid_feeding_titration": {
+        "liquid": "",
+        "observe": ""
+    },
+    "drip_back": {
+        "liquid": "",
+        "observe": ""
+    }
+}
+
+LOCATION_MAPPING = {}
+
+ACTION_NAMES = {}
+
+HTTP_SERVICE_CONFIG = {}

unilabos/devices/workstation/bioyond_studio/config.py.deprecated

@@ -1,329 +0,0 @@
-# config.py
-"""
-Bioyond工作站配置文件
-包含API配置、工作流映射、物料类型映射、仓库库位映射等所有配置信息
-"""
-
-from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
-
-# ============================================================================
-# 基础配置
-# ============================================================================
-
-# API配置
-API_CONFIG = {
-    "api_key": "DE9BDDA0",
-    "api_host": "http://192.168.1.200:44402"
-}
-
-# HTTP 报送服务配置
-HTTP_SERVICE_CONFIG = {
-    "http_service_host": "127.0.0.1",  # 监听地址
-    "http_service_port": 8080,        # 监听端口
-}
-
-# Deck配置 - 反应站工作台配置
-DECK_CONFIG = BIOYOND_PolymerReactionStation_Deck(setup=True)
-
-# ============================================================================
-# 工作流配置
-# ============================================================================
-
-# 工作流ID映射
-WORKFLOW_MAPPINGS = {
-    "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
-    "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
-    "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
-    "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
-    "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-    "Liquid_feeding(titration)": "3a16082a-96ac-0449-446a-4ed39f3365b6",
-    "liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
-    "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a",
-}
-
-# 工作流名称到显示名称的映射
-WORKFLOW_TO_SECTION_MAP = {
-    'reactor_taken_in': '反应器放入',
-    'reactor_taken_out': '反应器取出',
-    'Solid_feeding_vials': '固体投料-小瓶',
-    'Liquid_feeding_vials(non-titration)': '液体投料-小瓶（非滴定）',
-    'Liquid_feeding_solvents': '液体投料-溶剂',
-    'Liquid_feeding(titration)': '液体投料-滴定',
-    'liquid_feeding_beaker': '液体投料-烧杯',
-    'Drip_back': '液体回滴'
-}
-
-# 工作流步骤ID配置
-WORKFLOW_STEP_IDS = {
-    "reactor_taken_in": {
-        "config": "60a06f85-c5b3-29eb-180f-4f62dd7e2154"
-    },
-    "liquid_feeding_beaker": {
-        "liquid": "6808cda7-fee7-4092-97f0-5f9c2ffa60e3",
-        "observe": "1753c0de-dffc-4ee6-8458-805a2e227362"
-    },
-    "liquid_feeding_vials_non_titration": {
-        "liquid": "62ea6e95-3d5d-43db-bc1e-9a1802673861",
-        "observe": "3a167d99-6172-b67b-5f22-a7892197142e"
-    },
-    "liquid_feeding_solvents": {
-        "liquid": "1fcea355-2545-462b-b727-350b69a313bf",
-        "observe": "0553dfb3-9ac5-4ace-8e00-2f11029919a8"
-    },
-    "solid_feeding_vials": {
-        "feeding": "f7ae7448-4f20-4c1d-8096-df6fbadd787a",
-        "observe": "263c7ed5-7277-426b-bdff-d6fbf77bcc05"
-    },
-    "liquid_feeding_titration": {
-        "liquid": "a00ec41b-e666-4422-9c20-bfcd3cd15c54",
-        "observe": "ac738ff6-4c58-4155-87b1-d6f65a2c9ab5"
-    },
-    "drip_back": {
-        "liquid": "371be86a-ab77-4769-83e5-54580547c48a",
-        "observe": "ce024b9d-bd20-47b8-9f78-ca5ce7f44cf1"
-    }
-}
-
-# 工作流动作名称配置
-ACTION_NAMES = {
-    "reactor_taken_in": {
-        "config": "通量-配置",
-        "stirring": "反应模块-开始搅拌"
-    },
-    "solid_feeding_vials": {
-        "feeding": "粉末加样模块-投料",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "liquid_feeding_vials_non_titration": {
-        "liquid": "稀释液瓶加液位-液体投料",
-        "observe": "反应模块-滴定结果观察"
-    },
-    "liquid_feeding_solvents": {
-        "liquid": "试剂AB放置位-试剂吸液分液",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "liquid_feeding_titration": {
-        "liquid": "稀释液瓶加液位-稀释液吸液分液",
-        "observe": "反应模块-滴定结果观察"
-    },
-    "liquid_feeding_beaker": {
-        "liquid": "烧杯溶液放置位-烧杯吸液分液",
-        "observe": "反应模块-观察搅拌结果"
-    },
-    "drip_back": {
-        "liquid": "试剂AB放置位-试剂吸液分液",
-        "observe": "反应模块-向下滴定结果观察"
-    }
-}
-
-# ============================================================================
-# 仓库配置
-# ============================================================================
-# 说明:
-# - 出库和入库操作都需要UUID
-WAREHOUSE_MAPPING = {
-    # ========== 反应站仓库 ==========
-
-    # 堆栈1左 - 反应站左侧堆栈 (4行×4列=16个库位, A01～D04)
-    "堆栈1左": {
-        "uuid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
-        "site_uuids": {
-            "A01": "3a14aa17-0d49-11d7-a6e1-f236b3e5e5a3",
-            "A02": "3a14aa17-0d49-4bc5-8836-517b75473f5f",
-            "A03": "3a14aa17-0d49-c2bc-6222-5cee8d2d94f8",
-            "A04": "3a14aa17-0d49-3ce2-8e9a-008c38d116fb",
-            "B01": "3a14aa17-0d49-f49c-6b66-b27f185a3b32",
-            "B02": "3a14aa17-0d49-cf46-df85-a979c9c9920c",
-            "B03": "3a14aa17-0d49-7698-4a23-f7ffb7d48ba3",
-            "B04": "3a14aa17-0d49-1231-99be-d5870e6478e9",
-            "C01": "3a14aa17-0d49-be34-6fae-4aed9d48b70b",
-            "C02": "3a14aa17-0d49-11d7-0897-34921dcf6b7c",
-            "C03": "3a14aa17-0d49-9840-0bd5-9c63c1bb2c29",
-            "C04": "3a14aa17-0d49-8335-3bff-01da69ea4911",
-            "D01": "3a14aa17-0d49-2bea-c8e5-2b32094935d5",
-            "D02": "3a14aa17-0d49-cff4-e9e8-5f5f0bc1ef32",
-            "D03": "3a14aa17-0d49-4948-cb0a-78f30d1ca9b8",
-            "D04": "3a14aa17-0d49-fd2f-9dfb-a29b11e84099",
-        },
-    },
-
-    # 堆栈1右 - 反应站右侧堆栈 (4行×4列=16个库位, A05～D08)
-    "堆栈1右": {
-        "uuid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
-        "site_uuids": {
-            "A05": "3a14aa17-0d49-2c61-edc8-72a8ca7192dd",
-            "A06": "3a14aa17-0d49-60c8-2b00-40b17198f397",
-            "A07": "3a14aa17-0d49-ec5b-0b75-634dce8eed25",
-            "A08": "3a14aa17-0d49-3ec9-55b3-f3189c4ec53d",
-            "B05": "3a14aa17-0d49-6a4e-abcf-4c113eaaeaad",
-            "B06": "3a14aa17-0d49-e3f6-2dd6-28c2e8194fbe",
-            "B07": "3a14aa17-0d49-11a6-b861-ee895121bf52",
-            "B08": "3a14aa17-0d49-9c7d-1145-d554a6e482f0",
-            "C05": "3a14aa17-0d49-45c4-7a34-5105bc3e2368",
-            "C06": "3a14aa17-0d49-867e-39ab-31b3fe9014be",
-            "C07": "3a14aa17-0d49-ec56-c4b4-39fd9b2131e7",
-            "C08": "3a14aa17-0d49-1128-d7d9-ffb1231c98c0",
-            "D05": "3a14aa17-0d49-e843-f961-ea173326a14b",
-            "D06": "3a14aa17-0d49-4d26-a985-f188359c4f8b",
-            "D07": "3a14aa17-0d49-223a-b520-bc092bb42fe0",
-            "D08": "3a14aa17-0d49-4fa3-401a-6a444e1cca22",
-        },
-    },
-
-    # 站内试剂存放堆栈
-    "站内试剂存放堆栈": {
-        "uuid": "3a14aa3b-9fab-9d8e-d1a7-828f01f51f0c",
-        "site_uuids": {
-            "A01": "3a14aa3b-9fab-adac-7b9c-e1ee446b51d5",
-            "A02": "3a14aa3b-9fab-ca72-febc-b7c304476c78"
-        }
-    },
-
-
-    # 测量小瓶仓库（测密度）
-    "测量小瓶仓库": {
-        "uuid": "3a15012f-705b-c0de-3f9e-950c205f9921",
-        "site_uuids": {
-            "A01": "3a15012f-705e-0524-3161-c523b5aebc97",
-            "A02": "3a15012f-705e-7cd1-32ab-ad4fd1ab75c8",
-            "A03": "3a15012f-705e-a5d6-edac-bdbfec236260",
-            "B01": "3a15012f-705e-e0ee-80e0-10a6b3fc500d",
-            "B02": "3a15012f-705e-e499-180d-de06d60d0b21",
-            "B03": "3a15012f-705e-eff6-63f1-09f742096b26"
-        }
-    },
-
-    # 站内Tip盒堆栈 - 用于存放枪头盒 (耗材)
-    "站内Tip盒堆栈": {
-        "uuid": "3a14aa3a-2d3c-b5c1-9ddf-7c4a957d459a",
-        "site_uuids": {
-            "A01": "3a14aa3a-2d3d-e700-411a-0ddf85e1f18a",
-            "A02": "3a14aa3a-2d3d-a7ce-099a-d5632fdafa24",
-            "A03": "3a14aa3a-2d3d-bdf6-a702-c60b38b08501",
-            "B01": "3a14aa3a-2d3d-d704-f076-2a8d5bc72cb8",
-            "B02": "3a14aa3a-2d3d-c350-2526-0778d173a5ac",
-            "B03": "3a14aa3a-2d3d-bc38-b356-f0de2e44e0c7"
-        }
-    },
-    # ========== 配液站仓库 ==========
-    "粉末堆栈": {
-        "uuid": "3a14198e-6928-121f-7ca6-88ad3ae7e6a0",
-        "site_uuids": {
-            "A01": "3a14198e-6929-31f0-8a22-0f98f72260df",
-            "A02": "3a14198e-6929-4379-affa-9a2935c17f99",
-            "A03": "3a14198e-6929-56da-9a1c-7f5fbd4ae8af",
-            "A04": "3a14198e-6929-5e99-2b79-80720f7cfb54",
-            "B01": "3a14198e-6929-f525-9a1b-1857552b28ee",
-            "B02": "3a14198e-6929-bf98-0fd5-26e1d68bf62d",
-            "B03": "3a14198e-6929-2d86-a468-602175a2b5aa",
-            "B04": "3a14198e-6929-1a98-ae57-e97660c489ad",
-            "C01": "3a14198e-6929-46fe-841e-03dd753f1e4a",
-            "C02": "3a14198e-6929-72ac-32ce-9b50245682b8",
-            "C03": "3a14198e-6929-8a0b-b686-6f4a2955c4e2",
-            "C04": "3a14198e-6929-a0ec-5f15-c0f9f339f963",
-            "D01": "3a14198e-6929-1bc9-a9bd-3b7ca66e7f95",
-            "D02": "3a14198e-6929-3bd8-e6c7-4a9fd93be118",
-            "D03": "3a14198e-6929-dde1-fc78-34a84b71afdf",
-            "D04": "3a14198e-6929-7ac8-915a-fea51cb2e884"
-        }
-    },
-    "溶液堆栈": {
-        "uuid": "3a14198e-d723-2c13-7d12-50143e190a23",
-        "site_uuids": {
-            "A01": "3a14198e-d724-e036-afdc-2ae39a7f3383",
-            "A02": "3a14198e-d724-d818-6d4f-5725191a24b5",
-            "A03": "3a14198e-d724-b5bb-adf3-4c5a0da6fb31",
-            "A04": "3a14198e-d724-d378-d266-2508a224a19f",
-            "B01": "3a14198e-d724-afa4-fc82-0ac8a9016791",
-            "B02": "3a14198e-d724-be8a-5e0b-012675e195c6",
-            "B03": "3a14198e-d724-ab4e-48cb-817c3c146707",
-            "B04": "3a14198e-d724-f56e-468b-0110a8feb36a",
-            "C01": "3a14198e-d724-ca48-bb9e-7e85751e55b6",
-            "C02": "3a14198e-d724-cc1e-5c2c-228a130f40a8",
-            "C03": "3a14198e-d724-7f18-1853-39d0c62e1d33",
-            "C04": "3a14198e-d724-0cf1-dea9-a1f40fe7e13c",
-            "D01": "3a14198e-d724-df6d-5e32-5483b3cab583",
-            "D02": "3a14198e-d724-1e28-c885-574c3df468d0",
-            "D03": "3a14198e-d724-28a2-a760-baa896f46b66",
-            "D04": "3a14198e-d724-0ddd-9654-f9352a421de9"
-        }
-    },
-    "试剂堆栈": {
-        "uuid": "3a14198c-c2cc-0290-e086-44a428fba248",
-        "site_uuids": {
-            "A01": "3a14198c-c2cf-8b40-af28-b467808f1c36",  # x=1, y=1, code=0001-0001
-            "A02": "3a14198c-c2d0-dc7d-b8d0-e1d88cee3094",  # x=1, y=2, code=0001-0002
-            "A03": "3a14198c-c2d0-354f-39ad-642e1a72fcb8",  # x=1, y=3, code=0001-0003
-            "A04": "3a14198c-c2d0-725e-523d-34c037ac2440",  # x=1, y=4, code=0001-0004
-            "B01": "3a14198c-c2d0-f3e7-871a-e470d144296f",  # x=2, y=1, code=0001-0005
-            "B02": "3a14198c-c2d0-2070-efc8-44e245f10c6f",  # x=2, y=2, code=0001-0006
-            "B03": "3a14198c-c2d0-1559-105d-0ea30682cab4",  # x=2, y=3, code=0001-0007
-            "B04": "3a14198c-c2d0-efce-0939-69ca5a7dfd39"   # x=2, y=4, code=0001-0008
-        }
-    }
-}
-
-# ============================================================================
-# 物料类型配置
-# ============================================================================
-# 说明:
-# - 格式: PyLabRobot资源类型名称 → Bioyond系统typeId的UUID
-# - 这个映射基于 resource.model 属性 (不是显示名称!)
-# - UUID为空表示该类型暂未在Bioyond系统中定义
-MATERIAL_TYPE_MAPPINGS = {
-    # ================================================配液站资源============================================================
-    # ==================================================样品===============================================================
-    "BIOYOND_PolymerStation_1FlaskCarrier": ("烧杯", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),  # 配液站-样品-烧杯
-    "BIOYOND_PolymerStation_1BottleCarrier": ("试剂瓶", "3a14196b-8bcf-a460-4f74-23f21ca79e72"),  # 配液站-样品-试剂瓶
-    "BIOYOND_PolymerStation_6StockCarrier": ("分装板", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),  # 配液站-样品-分装板
-    "BIOYOND_PolymerStation_Liquid_Vial": ("10%分装小瓶", "3a14196c-76be-2279-4e22-7310d69aed68"),  # 配液站-样品-分装板-第一排小瓶
-    "BIOYOND_PolymerStation_Solid_Vial": ("90%分装小瓶", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),  # 配液站-样品-分装板-第二排小瓶
-    # ==================================================试剂===============================================================
-    "BIOYOND_PolymerStation_8StockCarrier": ("样品板", "3a14196e-b7a0-a5da-1931-35f3000281e9"),  # 配液站-试剂-样品板（8孔）
-    "BIOYOND_PolymerStation_Solid_Stock": ("样品瓶", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),  # 配液站-试剂-样品板-样品瓶
-
-}
-
-# ============================================================================
-# 动态生成的库位UUID映射（从WAREHOUSE_MAPPING中提取）
-# ============================================================================
-
-LOCATION_MAPPING = {}
-for warehouse_name, warehouse_config in WAREHOUSE_MAPPING.items():
-    if "site_uuids" in warehouse_config:
-        LOCATION_MAPPING.update(warehouse_config["site_uuids"])
-
-# ============================================================================
-# 物料默认参数配置
-# ============================================================================
-# 说明:
-# - 为特定物料名称自动添加默认参数（如密度、分子量、单位等）
-# - 格式: 物料名称 → {参数字典}
-# - 在创建或更新物料时，会自动合并这些参数到 Parameters 字段
-# - unit: 物料的计量单位（会用于 unit 字段）
-# - density/densityUnit: 密度信息（会添加到 Parameters 中）
-
-MATERIAL_DEFAULT_PARAMETERS = {
-    # 溶剂类
-    "NMP": {
-        "unit": "毫升",
-        "density": "1.03",
-        "densityUnit": "g/mL",
-        "description": "N-甲基吡咯烷酮 (N-Methyl-2-pyrrolidone)"
-    },
-    # 可以继续添加其他物料...
-}
-
-# ============================================================================
-# 物料类型默认参数配置
-# ============================================================================
-# 说明:
-# - 为特定物料类型（UUID）自动添加默认参数
-# - 格式: Bioyond类型UUID → {参数字典}
-# - 优先级低于按名称匹配的配置
-MATERIAL_TYPE_PARAMETERS = {
-    # 示例:
-    # "3a14196b-24f2-ca49-9081-0cab8021bf1a": {  # 烧杯
-    #     "unit": "个"
-    # }
-}