node_to_plr_dict: WareHouse 子节点不写入 PLR children 列表

WareHouse 通过 sites 字符串追踪占位，不依赖 PLR children tree。
当同一载架（如 BIOYOND_PolymerStation_1BottleCarrier）出现在多个
WareHouse 的 children 下时，PLR _check_naming_conflicts 会因
同名子资源（flask_1）重复而报 ValueError。

将 WareHouse 的 children 排除在 PLR dict 外，PLR 树只保留
WareHouse 本身（位置/尺寸），不包含其持有的载架。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.conda/scripts/post-link.bat

@@ -1,9 +0,0 @@
-@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

@@ -1,9 +0,0 @@
-#!/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

@@ -0,0 +1,328 @@
+---
+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

@@ -0,0 +1,240 @@
+---
+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

@@ -0,0 +1,319 @@
+---
+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

@@ -0,0 +1,233 @@
+---
+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

@@ -0,0 +1,357 @@
+---
+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

@@ -0,0 +1,353 @@
+---
+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

@@ -71,22 +71,6 @@ from unilabos.registry.decorators import action
 - `_` 开头的方法 → 不扫描
 - `@not_action` 标记的方法 → 排除
 
-### 参数文档 → JSON Schema 元数据
-
-在 `__init__` 和 action 方法 docstring 的 `Args:` 小节里，使用以下格式生成入参 schema 的显示信息：
-
-```python
-"""
-Args:
-    param[显示名称]: 参数说明，会写入 JSON Schema 的 description。
-"""
-```
-
-- `param[显示名称]` 的显示名称会写入 goal property 的 `title`。
-- `:` 后面的说明会写入 goal property 的 `description`。
-- 如果只写 `param: 参数说明`，`title` 会兜底为字段名，`description` 使用参数说明。
-- 如果没有写参数文档，生成器也会兜底补齐 `title=<字段名>` 和 `description=""`，但新设备应优先写清楚显示名和说明。
-
 ### @topic_config — 状态属性配置
 
 ```python
@@ -121,27 +105,13 @@ import logging
 from typing import Any, Dict, Optional
 
 from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.registry.decorators import action, device, not_action, topic_config
+from unilabos.registry.decorators import device, action, topic_config, not_action
 
-@device(
-    id="my_device",
-    category=["my_category"],
-    description="设备描述",
-    display_name="设备显示名",
-)
+@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):
-        """
-        初始化设备。
-
-        Args:
-            device_id[设备ID]: 设备实例 ID，默认使用 my_device。
-            config[设备配置]: 设备启动配置。
-        """
         self.device_id = device_id or "my_device"
         self.config = config or {}
         self.logger = logging.getLogger(f"MyDevice.{self.device_id}")
@@ -163,13 +133,7 @@ class MyDevice:
 
     @action(description="执行操作")
     def my_action(self, param: float = 0.0, name: str = "") -> Dict[str, Any]:
-        """
-        带 @action 装饰器 → 注册为 'my_action' 动作。
-
-        Args:
-            param[操作数值]: 操作使用的数值参数。
-            name[操作名称]: 操作名称或备注。
-        """
+        """带 @action 装饰器 → 注册为 'my_action' 动作"""
         return {"success": True}
 
     def get_info(self) -> Dict[str, Any]:

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

@@ -0,0 +1,251 @@
+---
+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

@@ -0,0 +1,58 @@
+# 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

@@ -0,0 +1,93 @@
+{
+  "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

@@ -0,0 +1,32 @@
+{
+  "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

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

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

@@ -0,0 +1,255 @@
+{
+  "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/virtual-workbench/SKILL.md

@@ -0,0 +1,272 @@
+---
+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

@@ -0,0 +1,76 @@
+# 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

@@ -0,0 +1,270 @@
+{
+  "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

@@ -0,0 +1,19 @@
+{
+  "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

@@ -0,0 +1,24 @@
+{
+  "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

@@ -0,0 +1,20 @@
+{
+  "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

@@ -0,0 +1,24 @@
+{
+  "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

@@ -0,0 +1,255 @@
+{
+  "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,26 +1,188 @@
-.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
+# ============================================================
+# 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/
 pyrightconfig.json
-# README.md
-# README_zh.md
-setup.py
-setup.cfg
-.gitattrubutes
-**/__pycache__
+
+# ==================== 其他 ====================
+# Catkin
+CATKIN_IGNORE
+
+# Eclipse/Qt
+.project
+.cproject
+CMakeLists.txt.user
+*.user
+qtcreator-*

.github/copilot-instructions.md

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

.github/dependabot.yml

@@ -0,0 +1,19 @@
+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"

.github/workflows/ci-check.yml

@@ -38,7 +38,7 @@ jobs:
       - name: Install ROS dependencies, uv and unilabos-msgs
         run: |
           echo Installing ROS dependencies...
-          mamba install -n check-env --override-channels -c robostack-staging -c conda-forge -c uni-lab conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -y
+          mamba install -n check-env conda-forge::uv conda-forge::opencv robostack-staging::ros-humble-ros-core robostack-staging::ros-humble-action-msgs robostack-staging::ros-humble-std-msgs robostack-staging::ros-humble-geometry-msgs robostack-staging::ros-humble-control-msgs robostack-staging::ros-humble-nav2-msgs uni-lab::ros-humble-unilabos-msgs robostack-staging::ros-humble-cv-bridge robostack-staging::ros-humble-vision-opencv robostack-staging::ros-humble-tf-transformations robostack-staging::ros-humble-moveit-msgs robostack-staging::ros-humble-tf2-ros robostack-staging::ros-humble-tf2-ros-py conda-forge::transforms3d -c robostack-staging -c conda-forge -c uni-lab -y
 
       - name: Install pip dependencies and unilabos
         run: |

.github/workflows/conda-pack-build.yml

@@ -1,10 +1,6 @@
 name: Build Conda-Pack Environment
 
 on:
-  # 在 UniLabOS Conda Build 成功上传后自动构建非全量 conda-pack
-  workflow_run:
-    workflows: ["UniLabOS Conda Build"]
-    types: [completed]
   workflow_dispatch:
     inputs:
       branch:
@@ -25,16 +21,6 @@ on:
 
 jobs:
   build-conda-pack:
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (
-        github.event_name == 'workflow_run' &&
-        github.event.workflow_run.conclusion == 'success' &&
-        github.event.workflow_run.event == 'workflow_run'
-      )
-    env:
-      BUILD_FULL: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}
-      PACKAGE_REF: ${{ github.event.inputs.branch || github.event.workflow_run.head_sha || github.ref_name }}
     strategy:
       fail-fast: false
       matrix:
@@ -68,9 +54,7 @@ jobs:
         id: should_build
         shell: bash
         run: |
-          if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
-            echo "should_build=true" >> $GITHUB_OUTPUT
-          elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
+          if [[ -z "${{ github.event.inputs.platforms }}" ]]; then
             echo "should_build=true" >> $GITHUB_OUTPUT
           elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
             echo "should_build=true" >> $GITHUB_OUTPUT
@@ -81,7 +65,7 @@ jobs:
       - uses: actions/checkout@v6
         if: steps.should_build.outputs.should_build == 'true'
         with:
-          ref: ${{ github.event.inputs.branch || github.event.workflow_run.head_sha || github.ref }}
+          ref: ${{ github.event.inputs.branch }}
           fetch-depth: 0
 
       - name: Setup Miniforge (with mamba)
@@ -91,7 +75,7 @@ jobs:
           miniforge-version: latest
           use-mamba: true
           python-version: '3.11.14'
-          channels: conda-forge,robostack-staging,uni-lab
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
           auto-update-conda: false
@@ -102,13 +86,13 @@ jobs:
         run: |
           echo Installing unilabos and dependencies to unilab environment...
           echo Using mamba for faster and more reliable dependency resolution...
-          echo Build full: ${{ env.BUILD_FULL }}
-          if "${{ env.BUILD_FULL }}"=="true" (
+          echo Build full: ${{ github.event.inputs.build_full }}
+          if "${{ github.event.inputs.build_full }}"=="true" (
             echo Installing unilabos-full ^(complete package^)...
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos-full conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           ) else (
             echo Installing unilabos ^(minimal package^)...
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           )
 
       - name: Install conda-pack, unilabos and dependencies (Unix)
@@ -117,13 +101,13 @@ jobs:
         run: |
           echo "Installing unilabos and dependencies to unilab environment..."
           echo "Using mamba for faster and more reliable dependency resolution..."
-          echo "Build full: ${{ env.BUILD_FULL }}"
-          if [[ "${{ env.BUILD_FULL }}" == "true" ]]; then
+          echo "Build full: ${{ github.event.inputs.build_full }}"
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "Installing unilabos-full (complete package)..."
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos-full conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos-full conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           else
             echo "Installing unilabos (minimal package)..."
-            mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos conda-pack zstandard -y
+            mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
           fi
 
       - name: Get latest ros-humble-unilabos-msgs version (Windows)
@@ -150,27 +134,27 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Checking for available ros-humble-unilabos-msgs versions...
-          mamba search --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs || echo Search completed
+          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo Search completed
           echo.
           echo Updating ros-humble-unilabos-msgs to latest version...
-          mamba update -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs -y || echo Already at latest version
+          mamba update -n unilab ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo Already at latest version
 
       - name: Check for newer ros-humble-unilabos-msgs (Unix)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
         shell: bash
         run: |
           echo "Checking for available ros-humble-unilabos-msgs versions..."
-          mamba search --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs || echo "Search completed"
+          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo "Search completed"
           echo ""
           echo "Updating ros-humble-unilabos-msgs to latest version..."
-          mamba update -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge ros-humble-unilabos-msgs -y || echo "Already at latest version"
+          mamba update -n unilab ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo "Already at latest version"
 
       - name: Install latest unilabos from source (Windows)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Uninstalling existing unilabos...
           mamba run -n unilab pip uninstall unilabos -y || echo unilabos not installed via pip
-          echo Installing unilabos from source (ref: ${{ env.PACKAGE_REF }})...
+          echo Installing unilabos from source (branch: ${{ github.event.inputs.branch }})...
           mamba run -n unilab pip install .
           echo Verifying installation...
           mamba run -n unilab pip show unilabos
@@ -181,7 +165,7 @@ jobs:
         run: |
           echo "Uninstalling existing unilabos..."
           mamba run -n unilab pip uninstall unilabos -y || echo "unilabos not installed via pip"
-          echo "Installing unilabos from source (ref: ${{ env.PACKAGE_REF }})..."
+          echo "Installing unilabos from source (branch: ${{ github.event.inputs.branch }})..."
           mamba run -n unilab pip install .
           echo "Verifying installation..."
           mamba run -n unilab pip show unilabos
@@ -242,9 +226,7 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         run: |
           echo Packing unilab environment with conda-pack...
-          for /f "delims=" %%i in ('mamba run -n unilab python -c "import os; print(os.environ['CONDA_PREFIX'])"') do set "UNILAB_PREFIX=%%i"
-          echo Packing environment at: %UNILAB_PREFIX%
-          mamba run -n unilab conda-pack -p "%UNILAB_PREFIX%" -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
+          mamba activate unilab && conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
           echo Pack file created:
           dir unilab-env-${{ matrix.platform }}.tar.gz
 
@@ -253,9 +235,8 @@ jobs:
         shell: bash
         run: |
           echo "Packing unilab environment with conda-pack..."
-          UNILAB_PREFIX="$(mamba run -n unilab python -c 'import os; print(os.environ["CONDA_PREFIX"])')"
-          echo "Packing environment at: $UNILAB_PREFIX"
-          mamba run -n unilab conda-pack -p "$UNILAB_PREFIX" -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
+          mamba install conda-pack -c conda-forge -y
+          conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
           echo "Pack file created:"
           ls -lh unilab-env-${{ matrix.platform }}.tar.gz
 
@@ -286,7 +267,7 @@ jobs:
 
           rem Create README using Python script
           echo Creating: README.txt
-          python scripts\create_readme.py ${{ matrix.platform }} ${{ env.PACKAGE_REF }} dist-package\README.txt
+          python scripts\create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package\README.txt
 
           echo.
           echo Distribution package contents:
@@ -322,7 +303,7 @@ jobs:
 
           # Create README using Python script
           echo "Creating: README.txt"
-          python scripts/create_readme.py ${{ matrix.platform }} ${{ env.PACKAGE_REF }} dist-package/README.txt
+          python scripts/create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package/README.txt
 
           echo ""
           echo "Distribution package contents:"
@@ -333,7 +314,7 @@ jobs:
         if: steps.should_build.outputs.should_build == 'true'
         uses: actions/upload-artifact@v6
         with:
-          name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}
+          name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
           path: dist-package/
           retention-days: 90
           if-no-files-found: error
@@ -345,9 +326,9 @@ jobs:
           echo Build Summary
           echo ==========================================
           echo Platform: ${{ matrix.platform }}
-          echo Branch: ${{ env.PACKAGE_REF }}
+          echo Branch: ${{ github.event.inputs.branch }}
           echo Python version: 3.11.14
-          if "${{ env.BUILD_FULL }}"=="true" (
+          if "${{ github.event.inputs.build_full }}"=="true" (
             echo Package: unilabos-full ^(complete^)
           ) else (
             echo Package: unilabos ^(minimal^)
@@ -356,7 +337,7 @@ jobs:
           echo Distribution package contents:
           dir dist-package
           echo.
-          echo Artifact name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}
+          echo Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
           echo.
           echo After download, extract the ZIP and run:
           echo   install_unilab.bat
@@ -370,9 +351,9 @@ jobs:
           echo "Build Summary"
           echo "=========================================="
           echo "Platform: ${{ matrix.platform }}"
-          echo "Branch: ${{ env.PACKAGE_REF }}"
+          echo "Branch: ${{ github.event.inputs.branch }}"
           echo "Python version: 3.11.14"
-          if [[ "${{ env.BUILD_FULL }}" == "true" ]]; then
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "Package: unilabos-full (complete)"
           else
             echo "Package: unilabos (minimal)"
@@ -381,7 +362,7 @@ jobs:
           echo "Distribution package contents:"
           ls -lh dist-package/
           echo ""
-          echo "Artifact name: unilab-pack-${{ matrix.platform }}-${{ env.PACKAGE_REF }}"
+          echo "Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}"
           echo ""
           echo "After download:"
           echo "  install_unilab.sh"

.github/workflows/deploy-docs.yml

@@ -56,7 +56,7 @@ jobs:
           miniforge-version: latest
           use-mamba: true
           python-version: '3.11.14'
-          channels: conda-forge,robostack-staging,uni-lab
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
           auto-update-conda: false
@@ -66,7 +66,7 @@ jobs:
         run: |
           echo "Installing unilabos and dependencies to unilab environment..."
           echo "Using mamba for faster and more reliable dependency resolution..."
-          mamba install -n unilab --override-channels -c uni-lab -c robostack-staging -c conda-forge uni-lab::unilabos -y
+          mamba install -n unilab uni-lab::unilabos -c uni-lab -c robostack-staging -c conda-forge -y
 
       - name: Install latest unilabos from source
         run: |

.github/workflows/multi-platform-build.yml

@@ -10,9 +10,6 @@ on:
   # 支持 tag 推送（不依赖 CI Check）
   push:
     tags: ['v*']
-  # GitHub Release 发布时自动构建并上传
-  release:
-    types: [published]
   # 手动触发
   workflow_dispatch:
     inputs:
@@ -83,7 +80,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.event.release.tag_name || github.ref }}
+          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
       - name: Check if platform should be built
@@ -99,13 +96,12 @@ jobs:
             echo "should_build=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Setup Miniforge
+      - name: Setup Miniconda
         if: steps.should_build.outputs.should_build == 'true'
         uses: conda-incubator/setup-miniconda@v3
         with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: conda-forge,robostack-staging
+          miniconda-version: 'latest'
+          channels: conda-forge,robostack-staging,defaults
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -114,7 +110,7 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install --override-channels -c conda-forge rattler-build anaconda-client -y
+          conda install -c conda-forge rattler-build anaconda-client
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
@@ -161,13 +157,7 @@ jobs:
           retention-days: 30
 
       - name: Upload to Anaconda.org (unilab organization)
-        if: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'release' ||
-            startsWith(github.ref, 'refs/tags/') ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
         run: |
           for package in $(find ./output -name "*.conda"); do
             echo "Uploading $package to unilab organization..."

.github/workflows/unilabos-conda-build.yml

@@ -1,10 +1,14 @@
 name: UniLabOS Conda Build
 
 on:
-  # 在 Multi-Platform Conda Build 成功上传 msgs 后自动触发
+  # 在 CI Check 成功后自动触发
   workflow_run:
-    workflows: ["Multi-Platform Conda Build"]
+    workflows: ["CI Check"]
     types: [completed]
+    branches: [main, dev]
+  # 标签推送时直接触发（发布版本）
+  push:
+    tags: ['v*']
   # 手动触发
   workflow_dispatch:
     inputs:
@@ -29,30 +33,30 @@ on:
         type: boolean
 
 jobs:
-  # 等待上游 msgs 构建完成的 job (仅用于 workflow_run 触发)
-  wait-for-upstream:
+  # 等待 CI Check 完成的 job (仅用于 workflow_run 触发)
+  wait-for-ci:
     runs-on: ubuntu-latest
     if: github.event_name == 'workflow_run'
     outputs:
       should_continue: ${{ steps.check.outputs.should_continue }}
     steps:
-      - name: Check upstream workflow status
+      - name: Check CI status
         id: check
         run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" && ( "${{ github.event.workflow_run.event }}" == "release" || "${{ github.event.workflow_run.event }}" == "push" ) ]]; then
+          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
             echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "Multi-Platform Conda Build passed for release/tag, proceeding with UniLabOS build"
+            echo "CI Check passed, proceeding with build"
           else
             echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "Upstream workflow is not a successful release/tag build (status: ${{ github.event.workflow_run.conclusion }}, event: ${{ github.event.workflow_run.event }}), skipping build"
+            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
           fi
 
   build:
-    needs: [wait-for-upstream]
-    # 运行条件：workflow_run 触发且上游成功，或者手动触发
+    needs: [wait-for-ci]
+    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
     if: |
       always() &&
-      (needs.wait-for-upstream.result == 'skipped' || needs.wait-for-upstream.outputs.should_continue == 'true')
+      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
     strategy:
       fail-fast: false
       matrix:
@@ -75,7 +79,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
         with:
-          # 如果是 workflow_run 触发，使用上游 conda 包构建的 commit
+          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
           ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
@@ -92,13 +96,12 @@ jobs:
             echo "should_build=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Setup Miniforge
+      - name: Setup Miniconda
         if: steps.should_build.outputs.should_build == 'true'
         uses: conda-incubator/setup-miniconda@v3
         with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: conda-forge,robostack-staging,uni-lab
+          miniconda-version: 'latest'
+          channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: strict
           activate-environment: build-env
           auto-update-conda: false
@@ -107,7 +110,7 @@ jobs:
       - name: Install rattler-build and anaconda-client
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          mamba install --override-channels -c conda-forge rattler-build anaconda-client -y
+          conda install -c conda-forge rattler-build anaconda-client
 
       - name: Show environment info
         if: steps.should_build.outputs.should_build == 'true'
@@ -116,11 +119,11 @@ jobs:
           conda list | grep -E "(rattler-build|anaconda-client)"
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
-          echo "Build full package: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}"
+          echo "Build full package: ${{ github.event.inputs.build_full || 'false' }}"
           echo "Building packages:"
           echo "  - unilabos-env (environment dependencies)"
           echo "  - unilabos (with pip package)"
-          if [[ "${{ github.event_name == 'workflow_dispatch' && github.event.inputs.build_full == 'true' }}" == "true" ]]; then
+          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
             echo "  - unilabos-full (complete package)"
           fi
 
@@ -131,12 +134,7 @@ jobs:
           rattler-build build -r .conda/environment/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
 
       - name: Upload unilabos-env to Anaconda.org (if enabled)
-        if: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
         run: |
           echo "Uploading unilabos-env to uni-lab organization..."
           for package in $(find ./output -name "unilabos-env*.conda"); do
@@ -151,12 +149,7 @@ jobs:
           rattler-build build -r .conda/base/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
 
       - name: Upload unilabos to Anaconda.org (if enabled)
-        if: |
-          steps.should_build.outputs.should_build == 'true' &&
-          (
-            github.event_name == 'workflow_run' ||
-            github.event.inputs.upload_to_anaconda == 'true'
-          )
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
         run: |
           echo "Uploading unilabos to uni-lab organization..."
           for package in $(find ./output -name "unilabos-0*.conda" -o -name "unilabos-[0-9]*.conda"); do
@@ -166,7 +159,6 @@ jobs:
       - name: Build unilabos-full - Only when explicitly requested
         if: |
           steps.should_build.outputs.should_build == 'true' && 
-          github.event_name == 'workflow_dispatch' &&
           github.event.inputs.build_full == 'true'
         run: |
           echo "Building unilabos-full package on ${{ matrix.platform }}..."
@@ -175,7 +167,6 @@ jobs:
       - name: Upload unilabos-full to Anaconda.org (if enabled)
         if: |
           steps.should_build.outputs.should_build == 'true' && 
-          github.event_name == 'workflow_dispatch' &&
           github.event.inputs.build_full == 'true' &&
           github.event.inputs.upload_to_anaconda == 'true'
         run: |

.gitignore

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

AGENTS.md

@@ -23,11 +23,8 @@ unilab --skip_env_check                   # skip auto-install of dependencies
 unilab --visual rviz|web|disable          # visualization mode
 unilab --is_slave                         # run as slave node
 
-# Workflow upload subcommand（P6.1 新增 --target_device；P6.1.1 新增 --target_model）
+# Workflow upload subcommand
 unilab workflow_upload -f <workflow.json> -n <name> --tags tag1 tag2
-unilab workflow_upload -f <workflow.json> --target_device prcxi                    # P6.1 默认；同上 P6 行为
-unilab workflow_upload -f <workflow.json> --target_device prcxi --target_model 9320  # P6.1.1：型号粒度
-unilab workflow_upload -f <workflow.json> --target_device beckman                  # 未来支持，需在 YAML 中声明 target_devices.beckman
 
 # Tests
 pytest tests/                              # all tests
@@ -75,86 +72,6 @@ pytest tests/resources/test_resourcetreeset.py::TestClassName::test_method  # si
 
 Example device graphs and experiment configs are in `unilabos/test/experiments/` (not `tests/`). Registry test fixtures in `unilabos/test/registry/`.
 
-### Labware Mapping Table (`labware_mapping.yaml`) — P6 + P6.1 + P6.1.1
-
-Opentrons → 目标仪器（PRCXI / Beckman / Tecan ...）的「槽位重映射 + labware 归类 +
-class_name 选择」全部外化到项目根的
-[`labware_mapping.yaml`](./labware_mapping.yaml)（与 `pyproject.toml` 同级，最显眼的位置）。
-要新增 SKU、新厂商、新型号、或调整 tip 量程档时，**只改 YAML，不改 Python**。
-
-- **YAML 两段顶层语义**（P6.1.1 起 `slot_remap` 已下沉到 `target_devices` 内）：
-  - `kinds` — 顺序敏感的 regex；把 labware 字符串归到 `trash / tip_rack / tube_rack / plate`。**全局段**，与目标仪器无关。
-  - `target_devices.<name>` — 按目标仪器组织的规则段，内含三个字段：
-    - `slot_remap` — 替代历史 `_map_deck_slot`（例：`4 → 13`、`8 → 14`、`12+trash → 16`）。
-    - `rules` — 顺序敏感的「`kind + hole_count + volume_min/volume_max` → `class_name`」规则，首个命中胜出。
-    - `models.<model_name>` — 可选的型号粒度覆盖（slot_remap / rules）；缺失字段自动继承厂商级。
-- **`target_devices` 内段名约定**：
-  - `default` — **固定段名**，兜底物料集 + 兜底 `slot_remap`。caller 传入的 `target_device` 在 `target_devices`
-    下未声明时，自动 fallback 到此段（loader 单次 warning，下游消费方零感知)。
-    **第一版按 prcxi 内容拷贝填充**（值仍是 `PRCXI_*`），但与 prcxi 段在 YAML 中
-    各自独立，可独立演进。**`default` 不支持 `models` 子段**——型号粒度差异必须落到具体仪器段。
-  - `prcxi` / `beckman` / `tecan` / ... — 具体仪器段（厂商粒度）；caller 显式
-    `--target_device <name>` 时命中。可在 `models.<model>` 下声明同厂商不同型号的差异。
-- **4 段 fallback 链**（`slot_remap` / `rules` 共用）：
-  1. `target_devices.<device>.models.<model>.<field>`（caller 同时传 device + model）
-  2. `target_devices.<device>.<field>`（厂商级；步骤 1 缺字段时静默 fallback）
-  3. `target_devices.default.<field>`（caller 传未声明 device，或步骤 2 缺字段；打 warning）
-  4. `_BUILTIN_DEFAULT.target_devices.default.<field>`（YAML 误删 default 段时的最后兜底）
-- **CLI 用法**：
-  - P6.1：`unilab workflow_upload -f <workflow.json> --target_device prcxi`
-    （`--target_device` snake-case，默认 `prcxi`；未声明的名字自动 fallback 到 `default` 段）。
-  - P6.1.1：可加 `--target_model <name>`（snake，可省略，默认 `None`）。
-    例：`unilab workflow_upload -f <workflow.json> --target_device prcxi --target_model 9320`。
-- **入口代码**：`unilabos/workflow/labware_mapping.py` 暴露 `remap_slot` / `infer_kind` /
-  `resolve_target_class` / `reload_mapping`。
-  API 签名（P6.1.1）：
-  - `remap_slot(raw_slot, object_type="", *, target_device="prcxi", target_model=None)`
-  - `resolve_target_class(target_device, kind, hole_count=None, volume=None, *, target_model=None)`
-  `workflow/common.py` 中 `_map_deck_slot` / `_infer_reagent_kind` /
-  `_apply_tip_rack_class_from_transfer_volumes` / `_apply_target_labware_class_auto_match` /
-  `_reconcile_slot_carrier_target_class` 都已转调 YAML 并透传 `target_device` / `target_model`；
-  YAML 未命中（孔数 / 体积超出 default 段覆盖范围）时 fallback 到
-  `prcxi_labware.get_prcxi_labware_template_specs` 的模板打分匹配，并打 warning 提示「请补到映射表」。
-- **`labware_info` 字段重命名**：P6 的 `prcxi_class_name` → P6.1 的 `target_class_name`，
-  13 处全部同步刷新；旧 schema（顶层 `vendors` / `slot_remap` 或任一 rule 内 `prcxi_class`）
-  会触发 loader warning 并整段 fallback 到 builtin 默认表。
-- **测试**：
-  - `pytest tests/workflow/test_labware_mapping.py` —— 45 项单元测试（含 P6.1 + P6.1.1 用例：
-    `test_remap_slot_model_level_overrides_device_level`、
-    `test_remap_slot_model_inherits_device_when_field_missing`、
-    `test_legacy_top_level_slot_remap_rejected`、
-    `test_default_section_models_subsection_warns` 等）。
-  - `pytest tests/workflow/test_build_protocol_graph_target_device.py` —— 6 项集成
-    测试（默认 / 显式 prcxi / unknown 段 fallback / per-device tip class / 字段重命名 /
-    P6.1.1 model-level slot_remap）。
-- **设计文档**：[`product_designs/protocol_convert/06-labware-mapping-table.md`](../product_designs/protocol_convert/06-labware-mapping-table.md)
-  （§11.7 = P6.1 多目标仪器选择，§11.8 = P6.1.1 槽位映射按厂商+型号分叉）。
-
-### P2 跨 slot transfer_liquid 合并（v2，已落地）
-
-当一次 phase 中存在「单源吸取 → 跨多个 plate 分发」（典型 `steps/51b9a5.json` 9 plate × 12 well = 108 条 1:1 dispense），Stage 2 + Stage 3 现在能把它折叠成 **1 个 merged set_liquid_from_plate + 1 个 transfer_liquid** 节点。
-
-- **Stage 2**（[`Protocols/protocol_converter/change_to_transfer_group.py`](../Protocols/protocol_converter/change_to_transfer_group.py)）：
-  - `_pair_mergeable` 只要求源 slot / tip 量程档 / use_channels 一致；不再要求 `_target_slot` 相同。
-  - `_merge_two_transfer_actions` 维护 `_target_slots: list[int]`（与 `_target_wells` 平行，每次 dispense 一条）。
-  - `export_transfer_actions` 通过 `_register_target_reagent_key` 统一注册 reagent_key：跨 slot 时按 `_target_slots` 顺序拼出 `action_args.targets: list[str]`（同板退化为 `str`）。
-  - 末尾 `pop` 全部 `_` 前缀字段（包括新增的 `_target_slots`）。
-- **Stage 3**（[`Uni-Lab-OS/unilabos/workflow/common.py`](unilabos/workflow/common.py)）：
-  - 新增 `_emit_merged_set_liquid(...)`：对 `params.targets: list[str]` 的 transfer_liquid 节点，在其上游插入一个 **merged `set_liquid_from_plate`** 跨板聚合器；其 `param.wells` 是按 dispense 顺序通过 cursor 走 `reagent[key].well` 得出的有序跨板 well refs；多入边（每 plate 一条 `create_resource.labware → wells_identifier`），单出边（`output_wells → transfer_liquid.targets_identifier`）。
-  - 把 `params["targets"]` 改写为 synthetic str `_merged_targets_<idx>` 并注册 `resource_last_writer`，保证 INPUT_PORT_MAPPING 走 P3 既有的单边路径。
-  - `OUTPUT_PORT_MAPPING` 在原始 `step.param.targets` 为 `list[str]` 时为每个 reagent_key 分别注册 transfer_liquid 的下游 writer。
-- **PRCXI runtime**（[`prcxi/prcxi.py`](unilabos/devices/liquid_handling/prcxi/prcxi.py)）：`change_slots` 改为遍历所有 source / target 的 parent plate 并按 plate name 去重（跨板 4 个 plate 都能 `update_pipetting_position`）。
-- **`liquid_handler_abstract.transfer_liquid`**：**完全不改动**，主循环 `i % num_targets` 与单边 + 单 list 完全兼容。
-
-CLI 行为不变：现有 `unilab workflow_upload -f <workflow.json> ...` 一切照旧；跨 slot 协议自动走 v2 路径。
-
-测试：
-- `pytest Protocols/protocol_converter/tests/test_cross_slot_merge.py` — Stage 2 单测 10 项。
-- `pytest tests/workflow/test_common_cross_slot_v2.py` — Stage 3 集成测试 6 项。
-- `pytest tests/devices/liquid_handling/test_set_liquid_from_plate_cross_plate.py` — device 跨板单测 6 项（pylabrobot 不全时优雅 skip）。
-
-设计文档：[`product_designs/protocol_convert/02-cross-slot-merge.md`](../product_designs/protocol_convert/02-cross-slot-merge.md)（§9 v2 设计 + §11 落地记录）。
-
 ## Code Conventions
 
 - Code comments and log messages in simplified Chinese

docs/ai_guides/agent_prompt_template.md

@@ -0,0 +1,344 @@
+# 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,13 +18,15 @@ 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`
+- 执行多设备复杂任务逻辑的**PLC**，Uni-Lab 提供了基于地址表的接入方式和点动工作流编写，测试代码位于 `unilabos/device_comms/modbus_plc/test/test_workflow.py`。详细框架说明请参考 {doc}`plc_framework`
 
 ---
 
 ## 其他工业通信协议：CANopen, Ethernet, OPCUA...
 
-【敬请期待】
+Uni-Lab 已实现基于 OPC UA 协议的 PLC 接管框架，用于后处理工站等项目。与 Modbus 框架相比，OPC UA 框架额外提供了自动节点发现、订阅推送、断线重连等特性。详细说明请参考 {doc}`plc_framework`。
+
+其他协议（CANopen、EtherCAT 等）【敬请期待】
 
 ## 没有接口的老设备老软件：使用 PyWinAuto
 

docs/developer_guide/plc_framework.md

@@ -0,0 +1,281 @@
+# 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,6 +17,9 @@ 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

labware_mapping.yaml

@@ -1,140 +0,0 @@
-# Opentrons → 目标仪器 物料映射表（P6.1.1）
-#
-# 两段顶层 key（P6.1.1 起 slot_remap 从顶层下沉到 target_devices 内）：
-#   kinds          : labware 字符串 → kind 归类（与目标仪器无关，**保留全局**）
-#   target_devices : 按目标仪器 + 型号组织；rule = kind + hole_count + volume_min/max → class_name；
-#                    slot_remap 也内嵌在 target_devices 下（按 deck 物理布局变化）
-#
-# target_devices 段内结构：
-#   target_devices.<device>:                    # 厂商段（必填）
-#     slot_remap: {...}                         # 厂商级默认 slot 映射（缺失 → 继承 default 段）
-#     rules:     [...]                          # 厂商级规则（缺失 → 继承 default 段）
-#     models:                                   # 同厂商多型号（可选；缺失 = 仅厂商级，不区分型号）
-#       <model_name>:                           # 型号子段
-#         slot_remap: {...}                     # 型号级覆盖（缺失 → 继承厂商级）
-#         rules:     [...]                      # 型号级覆盖（缺失 → 继承厂商级）
-#
-# 段名约定：
-#   target_devices.default : 兜底物料集 + 兜底 slot_remap。caller 传未声明的 target_device 时使用此段。
-#                            **不支持 models 子段**（型号粒度差异必须落到具体仪器段，否则歧义）。
-#   target_devices.<name>  : 具体仪器段（prcxi / beckman / tecan ...）。
-#
-# 解析链（remap_slot / resolve_target_class 共用，字段级 fallback）：
-#   1. target_devices.<device>.models.<model>.<field>   (caller 同时传 device + model)
-#   2. target_devices.<device>.<field>                  (caller 传 device，或步骤 1 缺字段)
-#   3. target_devices.default.<field>                   (caller 传未声明 device，或步骤 2 缺字段)
-#   4. _BUILTIN_DEFAULT.target_devices.default.<field>  (YAML 误删 default 段时的最后兜底)
-#
-# 编辑建议：
-#   1. 顺序敏感：kinds 与 rules 内首个命中胜出；窄规则在前、宽规则在后。
-#   2. volume_min / volume_max 是闭区间（µL）。任一字段可省略；都省略 = 不限制体积。
-#   3. notes 仅作注释，不参与匹配。
-#   4. 新增目标仪器：复制 target_devices.prcxi 段、改 device 名、改 slot_remap + rules。
-#   5. 同厂商不同型号：在 target_devices.<device>.models.<model> 下显式覆盖差异字段；
-#      没声明的字段自动继承厂商级。
-#   6. P6.1.1 不再支持顶层 slot_remap；检出顶层 slot_remap → warning + fallback 到 builtin。
-#
-# 设计文档：product_designs/protocol_convert/06-labware-mapping-table.md（§11.8）
-
-kinds:
-  # 顺序敏感的 regex；第一个命中胜出
-  # 注意：trash 必须在 tip_rack 之前；tip_rack 必须在 tube_rack 之前（"tuberack" 含 "rack"）
-  - { pattern: "trash",                                                         kind: trash }
-  - { pattern: "tiprack|tip[_ ]?rack|opentrons_\\d+_tiprack",                    kind: tip_rack }
-  - { pattern: "tuberack|tube[_ ]rack|eppendorf.*rack|safelock.*rack",          kind: tube_rack }
-  # 「<labware> 含 'rack' 但不含 'tip'」也归到 tube_rack（与历史 _infer_reagent_kind 行为一致）
-  - { pattern: "(?:^|[^a-z])rack(?:[^a-z]|$)",                                  kind: tube_rack }
-  - { pattern: ".*",                                                            kind: plate }
-
-target_devices:
-  # ─────────────────────────────────────────────────────────────────────────
-  # default：兜底物料集 + 兜底 slot_remap。
-  # caller 传未声明的 target_device 时使用本段；**不支持 models 子段**。
-  # 第一版内容按 prcxi 拷贝填充（值仍是 PRCXI_*），但语义独立，可独立演进。
-  # ─────────────────────────────────────────────────────────────────────────
-  default:
-    notes: "默认兜底物料集；caller 传未声明 target_device 时使用此段。第一版按 prcxi 拷贝填充。"
-    slot_remap:
-      # raw slot → deck slot；与对象类型无关
-      default:
-        "4": "13"
-        "8": "14"
-      # 按 object 字段覆盖 default
-      by_object:
-        trash:
-          "12": "16"
-    rules:
-      # ─ tip rack（默认量程档：≤10 / <300 / 否则 1000） ─
-      - { kind: tip_rack,  hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips }
-      - { kind: tip_rack,  hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips }
-      - { kind: tip_rack,  hole_count: 96,                    class_name: PRCXI_1000uL_Tips }
-      # ─ tube rack ─
-      - { kind: tube_rack, hole_count: 24, class_name: PRCXI_EP_Adapter, notes: "Eppendorf 1.5/2 mL 24 位 4×6" }
-      - { kind: tube_rack, hole_count: 10, class_name: PRCXI_EP_Adapter, notes: "Falcon 4x50 + 6x15 mL（10 位兼容 4×6 适配器）" }
-      # ─ plate ─
-      - { kind: plate,     hole_count: 96,  class_name: PRCXI_BioER_96_wellplate }
-      - { kind: plate,     hole_count: 384, class_name: PRCXI_BioER_384_wellplate }
-      # ─ trash ─
-      - { kind: trash,                       class_name: PRCXI_trash }
-
-  # ─────────────────────────────────────────────────────────────────────────
-  # prcxi：PRCXI 仪器专用段。caller 显式传 --target_device prcxi 时命中此段。
-  # 厂商级 slot_remap + rules 适用于"未声明 model"的调用；
-  # models 子段下声明同厂商不同型号的 deck 物理布局差异。
-  # ─────────────────────────────────────────────────────────────────────────
-  prcxi:
-    slot_remap:
-      # PRCXI 多数型号通用的 deck 物理布局映射
-      default:
-        "4": "13"
-        "8": "14"
-      by_object:
-        trash:
-          "12": "16"
-    rules:
-      # ─ tip rack（PRCXI 量程档：≤10 / <300 / 否则 1000） ─
-      - { kind: tip_rack,  hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips }
-      - { kind: tip_rack,  hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips }
-      - { kind: tip_rack,  hole_count: 96,                    class_name: PRCXI_1000uL_Tips }
-      # ─ tube rack ─
-      - { kind: tube_rack, hole_count: 24, class_name: PRCXI_EP_Adapter, notes: "Eppendorf 1.5/2 mL 24 位 4×6" }
-      - { kind: tube_rack, hole_count: 10, class_name: PRCXI_EP_Adapter, notes: "Falcon 4x50 + 6x15 mL（10 位兼容 4×6 适配器）" }
-      # ─ plate ─
-      - { kind: plate,     hole_count: 96,  class_name: PRCXI_BioER_96_wellplate }
-      - { kind: plate,     hole_count: 384, class_name: PRCXI_BioER_384_wellplate }
-      # ─ trash ─
-      - { kind: trash,                       class_name: PRCXI_trash }
-    models:
-      # PRCXI 9320 —— 与厂商级完全一致（空 dict 仅作为合法 model 名占位）。
-      # caller `--target_model 9320` 时所有字段继承厂商级 prcxi 段。
-      "9320": {}
-      # 演示：假想 PRCXI 4040 把 slot 4 物理位换到 16、trash 槽换到 20。
-      # 仅 slot_remap 不同；rules 与厂商级一致 → 不重复声明（自动继承）。
-      "4040":
-        slot_remap:
-          default:
-            "4": "16"
-            "8": "14"
-          by_object:
-            trash:
-              "12": "20"
-
-  # ─────────────────────────────────────────────────────────────────────────
-  # 演示：未来加新仪器只复制 prcxi 段、改 device 名 + slot_remap + rules。
-  # 特别注意 tip 量程档可与 PRCXI 不同。
-  # ─────────────────────────────────────────────────────────────────────────
-  # beckman:
-  #   slot_remap:
-  #     default: {"4": "13"}
-  #     by_object: {trash: {"12": "16"}}
-  #   rules:
-  #     - { kind: tip_rack,  hole_count: 96, volume_max: 20,    class_name: Beckman_20uL_Tips }
-  #     - { kind: tip_rack,  hole_count: 96, volume_max: 199.9, class_name: Beckman_200uL_Tips }
-  #     - { kind: tip_rack,  hole_count: 96,                    class_name: Beckman_1000uL_Tips }
-  #     - { kind: tube_rack, hole_count: 24, class_name: Beckman_24_TubeRack }
-  #     - { kind: plate,     hole_count: 96, class_name: Beckman_BioMek_96_wellplate }
-  #     - { kind: trash,                      class_name: Beckman_Trash }
-  #   models:
-  #     "i7":
-  #       slot_remap:
-  #         default: {"4": "13", "5": "14"}    # 假想 i7 多一个 slot 重映射

recipes/conda_build_config.yaml

@@ -1,5 +1,5 @@
 channel_sources:
-  - robostack,robostack-staging,conda-forge
+  - robostack,robostack-staging,conda-forge,defaults
   
 gazebo:
   - '11'

test/devices/test_prcxi.py

@@ -1,539 +0,0 @@
-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

@@ -1,15 +0,0 @@
-# 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/test_liquid_history.py

@@ -1,244 +0,0 @@
-"""P9 — ``liquid_history`` schema v3 + helper 单元测试。
-
-测试覆盖：
-    - :func:`append_liquid_history`：写 v3 entry / tracker 缺失 graceful / 滚动上限
-    - :func:`normalize_liquid_history`：v3 dict / v2 tuple / list[str] / 混合 / 非法
-    - :func:`well_current_liquid_name`：tracker.liquids 末项 / get_liquids fallback / 缺失
-
-注：``LiquidHandlerAbstract.set_liquid`` 写 history 的集成（"set" action）覆盖
-逻辑相同（直接调用 :func:`append_liquid_history`），由本测试间接验证；端到端走 PLR
-真实 ``Well.set_liquids`` 的集成测试在 ``tests/devices/liquid_handling/unit_test.py``
-范围内随 PLR 环境就绪后增补，本 P9 提交保持解耦。
-
-详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md`` §8。
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, List, Tuple
-
-import pytest
-
-# liquid_history 模块**不依赖** pylabrobot，可在 PLR 环境缺失时独立 import / 单测。
-from unilabos.devices.liquid_handling.liquid_history import (
-    LIQUID_HISTORY_MAX_ENTRIES,
-    LiquidHistoryEntry,
-    append_liquid_history,
-    normalize_liquid_history,
-    well_current_liquid_name,
-)
-
-
-# ---------------------------------------------------------------------------
-# Fixtures：DummyTracker / DummyWell（避免引入真实 PLR Well/VolumeTracker 依赖）
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class DummyTracker:
-    """模拟 PLR VolumeTracker：仅暴露 P9 hook 关心的字段。"""
-
-    liquid_history: List[Any] = field(default_factory=list)
-    liquids: List[Tuple[Any, float]] = field(default_factory=list)
-    max_volume: float = 200.0
-    is_disabled: bool = False
-
-
-@dataclass
-class DummyWell:
-    """模拟 PLR Well：仅暴露 ``tracker``。"""
-
-    name: str = "well_A1"
-    max_volume: float = 200.0
-    tracker: DummyTracker = field(default_factory=DummyTracker)
-
-
-# ---------------------------------------------------------------------------
-# append_liquid_history
-# ---------------------------------------------------------------------------
-
-
-class TestAppendLiquidHistory:
-    def test_append_creates_v3_entry(self) -> None:
-        well = DummyWell()
-        append_liquid_history(well, "Plasma", 100.0, "set")
-
-        assert len(well.tracker.liquid_history) == 1
-        entry = well.tracker.liquid_history[0]
-        assert entry["name"] == "Plasma"
-        assert entry["volume"] == 100.0
-        assert entry["action"] == "set"
-        assert "timestamp" in entry and isinstance(entry["timestamp"], str)
-
-    def test_append_aspirate_negative_volume(self) -> None:
-        well = DummyWell()
-        append_liquid_history(well, "Water", -50.0, "aspirate")
-
-        assert well.tracker.liquid_history[0]["volume"] == -50.0
-        assert well.tracker.liquid_history[0]["action"] == "aspirate"
-
-    def test_append_with_empty_name_keeps_empty_string(self) -> None:
-        """name 为空时应写入 ``""`` 而非字面 "unknown"（避免视觉混淆 bottom_type）。"""
-        well = DummyWell()
-        append_liquid_history(well, "", 50.0, "dispense")
-
-        assert well.tracker.liquid_history[0]["name"] == ""
-
-    def test_append_with_none_name_normalized_to_empty_string(self) -> None:
-        well = DummyWell()
-        append_liquid_history(well, None, 50.0, "dispense")  # type: ignore[arg-type]
-
-        assert well.tracker.liquid_history[0]["name"] == ""
-
-    def test_append_initializes_history_if_missing(self) -> None:
-        """tracker 没有 liquid_history 属性时 helper 自动创建空 list 并写入。"""
-        well = DummyWell()
-        del well.tracker.liquid_history  # 模拟全新 PLR tracker
-        append_liquid_history(well, "X", 10.0, "set")
-
-        assert hasattr(well.tracker, "liquid_history")
-        assert len(well.tracker.liquid_history) == 1
-
-    def test_append_no_tracker_is_graceful(self) -> None:
-        """well 无 tracker 时静默不抛（保护主流程）。"""
-
-        class NoTrackerWell:
-            name = "no_tracker"
-
-        well = NoTrackerWell()
-        append_liquid_history(well, "X", 10.0, "set")  # 不应抛
-        assert not hasattr(well, "tracker")
-
-    def test_append_action_defaults_to_legacy_when_empty(self) -> None:
-        well = DummyWell()
-        append_liquid_history(well, "X", 1.0, "")
-
-        assert well.tracker.liquid_history[0]["action"] == "legacy"
-
-    def test_append_respects_max_entries_rolling(self) -> None:
-        """超过 ``LIQUID_HISTORY_MAX_ENTRIES`` 时丢弃头部，保留最近 entries。"""
-        well = DummyWell()
-        well.tracker.liquid_history = [
-            {"name": f"old_{i}"} for i in range(LIQUID_HISTORY_MAX_ENTRIES + 5)
-        ]
-        append_liquid_history(well, "newest", 1.0, "set")
-
-        assert len(well.tracker.liquid_history) == LIQUID_HISTORY_MAX_ENTRIES
-        assert well.tracker.liquid_history[-1]["name"] == "newest"
-        assert well.tracker.liquid_history[0]["name"] != "old_0"
-
-
-# ---------------------------------------------------------------------------
-# normalize_liquid_history
-# ---------------------------------------------------------------------------
-
-
-class TestNormalizeLiquidHistory:
-    def test_v3_dict_passthrough_with_field_defaults(self) -> None:
-        raw = [{"name": "A", "volume": 100, "action": "set", "timestamp": "2026-05-22T00:00:00Z"}]
-        result = normalize_liquid_history(raw)
-
-        assert result == [{
-            "name": "A",
-            "volume": 100.0,
-            "action": "set",
-            "timestamp": "2026-05-22T00:00:00Z",
-        }]
-
-    def test_v3_dict_missing_optional_fields_filled_with_defaults(self) -> None:
-        raw = [{"name": "A"}]
-        result = normalize_liquid_history(raw)
-
-        assert result == [{"name": "A", "volume": 0.0, "action": "legacy"}]
-        assert "timestamp" not in result[0]
-
-    def test_v2_tuple_upgraded_to_v3_legacy(self) -> None:
-        raw = [("A", 100), ("B", 50.5)]
-        result = normalize_liquid_history(raw)
-
-        assert result == [
-            {"name": "A", "volume": 100.0, "action": "legacy"},
-            {"name": "B", "volume": 50.5, "action": "legacy"},
-        ]
-
-    def test_list_of_strings_upgraded(self) -> None:
-        raw = ["A", "B"]
-        result = normalize_liquid_history(raw)
-
-        assert result == [
-            {"name": "A", "volume": 0.0, "action": "legacy"},
-            {"name": "B", "volume": 0.0, "action": "legacy"},
-        ]
-
-    def test_mixed_input_normalized(self) -> None:
-        raw = [
-            {"name": "A", "volume": 1, "action": "set"},
-            ("B", 2),
-            "C",
-        ]
-        result = normalize_liquid_history(raw)
-
-        assert [e["name"] for e in result] == ["A", "B", "C"]
-        assert [e["action"] for e in result] == ["set", "legacy", "legacy"]
-
-    def test_invalid_entries_dropped(self) -> None:
-        raw = [42, None, {"name": "A"}, ("only_one",)]
-        result = normalize_liquid_history(raw)
-
-        # 只保留 {"name": "A"} 这一条；其它都被丢弃
-        assert len(result) == 1
-        assert result[0]["name"] == "A"
-        assert result[0]["volume"] == 0.0  # 缺省补 0
-
-    def test_non_list_input_returns_empty(self) -> None:
-        assert normalize_liquid_history(None) == []
-        assert normalize_liquid_history("not_a_list") == []
-        assert normalize_liquid_history({"name": "X"}) == []
-
-    def test_tuple_with_unconvertible_volume_falls_back_to_zero(self) -> None:
-        raw = [("A", "not_a_number")]
-        result = normalize_liquid_history(raw)
-
-        assert result[0]["volume"] == 0.0
-
-
-# ---------------------------------------------------------------------------
-# well_current_liquid_name
-# ---------------------------------------------------------------------------
-
-
-class TestWellCurrentLiquidName:
-    def test_returns_last_liquid_name_from_tuple(self) -> None:
-        well = DummyWell()
-        well.tracker.liquids = [("Water", 50.0), ("Plasma", 100.0)]
-        assert well_current_liquid_name(well) == "Plasma"
-
-    def test_returns_enum_like_name_attr(self) -> None:
-        class FakeLiquid:
-            name = "ETHANOL"
-
-        well = DummyWell()
-        well.tracker.liquids = [(FakeLiquid(), 100.0)]
-        assert well_current_liquid_name(well) == "ETHANOL"
-
-    def test_empty_liquids_returns_empty_string(self) -> None:
-        well = DummyWell()
-        well.tracker.liquids = []
-        assert well_current_liquid_name(well) == ""
-
-    def test_no_tracker_returns_empty_string(self) -> None:
-        class NoTrackerWell:
-            name = "x"
-
-        assert well_current_liquid_name(NoTrackerWell()) == ""
-
-    def test_none_liquid_returns_empty_string(self) -> None:
-        well = DummyWell()
-        well.tracker.liquids = [(None, 100.0)]
-        assert well_current_liquid_name(well) == ""
-
-    def test_string_liquid_returned_as_is(self) -> None:
-        well = DummyWell()
-        well.tracker.liquids = ["Saline"]
-        assert well_current_liquid_name(well) == "Saline"

tests/devices/liquid_handling/test_set_liquid_from_plate_cross_plate.py

@@ -1,239 +0,0 @@
-"""P2 v2 跨板能力验证 —— device 层 ``set_liquid_from_plate`` 单测。
-
-对应 ``product_designs/protocol_convert/02-cross-slot-merge.md`` §9.1 / §9.5 step 6.3。
-
-本测试聚焦于 **`_set_liquid_grouped_by_plate`** 已天然支持跨板 wells 的能力（v2 设计
-的核心依据）：
-
-- 输入 ``wells`` 列表来自多个 plate（每板各一/多个 well）时，``set_liquid`` 应按 plate
-  分桶串行调用，每板一次（plate-bucket 顺序按 first-occurrence）。
-- 同板内多孔归到同一桶。
-- 返回 ``volumes`` 按 **输入 index 顺序**回拼，与 wells 一致 —— 这是 v2 Stage 3
-  merged ``set_liquid_from_plate.output_wells`` 的顺序权威来源。
-- ``Well.set_liquids`` 在 ``set_liquid`` 链内被逐孔调用，与 PLR 实现的预期接口一致。
-
-为了避免引入完整 PLR 资源树，测试用 duck-typed ``DummyWell`` / ``DummyPlate`` +
-``ResourceTreeSet`` 的 monkeypatch（dump 直接返回输入列表）。
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import List, Tuple
-
-import pytest
-
-
-# ----------------------------------------------------------------------
-# 跨环境兼容：与现有 ``tests/devices/liquid_handling/test_transfer_liquid.py`` 一致，
-# 本测试通过 import ``unilabos.devices.liquid_handling.liquid_handler_abstract``
-# 拉起 pylabrobot 链；某些本地开发机的 pylabrobot 版本与代码库要求不一致，
-# 会在 import 阶段抛 ``ImportError``。这里用 ``importorskip`` 优雅跳过，让
-# CI（统一 pylabrobot 版本）跑全；纯逻辑测试（Stage 2 / Stage 3）不受影响。
-# ----------------------------------------------------------------------
-LiquidHandlerAbstract = pytest.importorskip(
-    "unilabos.devices.liquid_handling.liquid_handler_abstract",
-    reason="pylabrobot 链未完整可用，跳过 device 单测；CI 上请保证 pylabrobot ≥ 项目要求版本",
-    exc_type=ImportError,
-).LiquidHandlerAbstract
-
-
-# ==================== Duck-typed PLR-like 资源 ====================
-
-
-@dataclass
-class DummyPlate:
-    name: str
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyPlate({self.name})"
-
-
-@dataclass
-class DummyWell:
-    name: str
-    parent: DummyPlate
-    max_volume: float = 1000.0
-    liquid_history: List[Tuple[str, float]] = field(default_factory=list)
-
-    def set_liquids(self, items):
-        """模拟 PLR ``Well.set_liquids([(name, vol), ...])`` 接口。"""
-        for name, vol in items:
-            self.liquid_history.append((str(name), float(vol)))
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyWell({self.parent.name}/{self.name})"
-
-
-# ==================== fixture：装一台 FakeLiquidHandler ====================
-
-
-@pytest.fixture
-def patched_resource_tree(monkeypatch):
-    """patch ``ResourceTreeSet.from_plr_resources`` 使其接受 duck-typed wells/plates。
-
-    返回的对象只要带 ``.dump()`` 即可（``_set_liquid_grouped_by_plate`` 仅消费该方法）。
-    """
-    from unilabos.devices.liquid_handling import liquid_handler_abstract as lha
-
-    class _FakeTree:
-        def __init__(self, items):
-            self._items = items
-
-        def dump(self):
-            return [
-                {"name": getattr(x, "name", None), "type": type(x).__name__}
-                for x in self._items
-            ]
-
-    def _fake_from_plr_resources(items, known_newly_created=False):  # noqa: ARG001
-        return _FakeTree(list(items))
-
-    monkeypatch.setattr(
-        lha.ResourceTreeSet,
-        "from_plr_resources",
-        staticmethod(_fake_from_plr_resources),
-    )
-    return lha
-
-
-@pytest.fixture
-def handler(patched_resource_tree):
-    """构造一台最小 LiquidHandlerAbstract 实例，绕过真实 backend / deck。"""
-
-    class _FakeHandler(LiquidHandlerAbstract):
-        def __init__(self):
-            # 不调用 super().__init__，避免真实硬件/后端依赖
-            self.channel_num = 8
-            self.support_touch_tip = True
-
-    return _FakeHandler()
-
-
-def _wells_grid(plate_name: str, well_names: List[str]) -> List[DummyWell]:
-    plate = DummyPlate(name=plate_name)
-    return [DummyWell(name=w, parent=plate) for w in well_names]
-
-
-# ==================== 用例 ====================
-
-
-def test_grouped_by_plate_single_plate_set_liquid_inline(handler):
-    """单 plate 多孔：set_liquids 按 wells 顺序逐项调用，volumes 回拼一致。"""
-    wells = _wells_grid("plate_slot2", ["A1", "A2", "A3"])
-    ret = handler._set_liquid_grouped_by_plate(
-        wells=wells,
-        liquid_names=["reagent_X"] * 3,
-        volumes=[10.0, 20.0, 30.0],
-    )
-
-    # 每个 well 的 liquid_history 各 1 条
-    for w, expected_vol in zip(wells, [10.0, 20.0, 30.0]):
-        assert w.liquid_history == [("reagent_X", expected_vol)]
-
-    # 返回 volumes 顺序与输入一致
-    assert ret.volumes == [10.0, 20.0, 30.0]
-
-
-def test_grouped_by_plate_cross_plate_buckets_by_parent(handler):
-    """跨板 wells 列表 → 按 first-occurrence plate 顺序分桶，每板单独 set_liquid。
-
-    51b9a5 简化（每板 1 孔）：4 plate × 1 well = 4 set_liquids 调用。
-    """
-    p2 = _wells_grid("plate_slot2", ["A1"])
-    p3 = _wells_grid("plate_slot3", ["A1"])
-    p5 = _wells_grid("plate_slot5", ["A1"])
-    p6 = _wells_grid("plate_slot6", ["A1"])
-    wells = p2 + p3 + p5 + p6
-
-    ret = handler._set_liquid_grouped_by_plate(
-        wells=wells,
-        liquid_names=["l1"] * 4,
-        volumes=[8.3] * 4,
-    )
-
-    # 每个 well 都被 set_liquids 设过
-    for w in wells:
-        assert w.liquid_history == [("l1", 8.3)], f"well {w.parent.name}/{w.name} 未正确设液"
-
-    # volumes 顺序与输入对齐
-    assert ret.volumes == [8.3, 8.3, 8.3, 8.3]
-
-    # plate dump 应含 4 个 plate（按 first-occurrence）
-    plate_dump = ret.plate
-    plate_names = [p["name"] for p in plate_dump]
-    assert plate_names == ["plate_slot2", "plate_slot3", "plate_slot5", "plate_slot6"]
-
-
-def test_grouped_by_plate_interleaved_cross_plate_preserves_input_order(handler):
-    """交错跨板：wells=[p2.A1, p3.A1, p2.A2, p5.A1] → volumes 顺序按输入回拼。
-
-    内部仍按 plate 分桶执行 set_liquid（per-plate 串行），但返回顺序遵循输入 index。
-    """
-    p2 = DummyPlate(name="plate_slot2")
-    p3 = DummyPlate(name="plate_slot3")
-    p5 = DummyPlate(name="plate_slot5")
-    w_p2_a1 = DummyWell(name="A1", parent=p2)
-    w_p2_a2 = DummyWell(name="A2", parent=p2)
-    w_p3_a1 = DummyWell(name="A1", parent=p3)
-    w_p5_a1 = DummyWell(name="A1", parent=p5)
-
-    wells = [w_p2_a1, w_p3_a1, w_p2_a2, w_p5_a1]
-    ret = handler._set_liquid_grouped_by_plate(
-        wells=wells,
-        liquid_names=["l1"] * 4,
-        volumes=[10.0, 20.0, 30.0, 40.0],
-    )
-
-    # 每个 well 都被设液
-    assert w_p2_a1.liquid_history == [("l1", 10.0)]
-    assert w_p3_a1.liquid_history == [("l1", 20.0)]
-    assert w_p2_a2.liquid_history == [("l1", 30.0)]
-    assert w_p5_a1.liquid_history == [("l1", 40.0)]
-
-    # 返回 volumes 严格按输入 index 顺序回拼
-    assert ret.volumes == [10.0, 20.0, 30.0, 40.0]
-
-    # plate dump：按 first-occurrence（plate_slot2 第 1 次出现于 idx=0，plate_slot3 idx=1，plate_slot5 idx=3）
-    plate_names = [p["name"] for p in ret.plate]
-    assert plate_names == ["plate_slot2", "plate_slot3", "plate_slot5"]
-
-
-def test_grouped_by_plate_volumes_clamped_to_max_volume(handler):
-    """``set_liquid`` 会按 ``max_volume`` 做 clamp，防止初始化液量超容器容量。"""
-    plate = DummyPlate(name="plate_slot2")
-    well = DummyWell(name="A1", parent=plate, max_volume=200.0)
-
-    ret = handler._set_liquid_grouped_by_plate(
-        wells=[well],
-        liquid_names=["overflow"],
-        volumes=[500.0],          # 超过 max_volume=200
-    )
-
-    assert well.liquid_history == [("overflow", 200.0)]
-    assert ret.volumes == [200.0]
-
-
-def test_grouped_by_plate_empty_names_short_circuit(handler):
-    """``liquid_names`` 与 ``volumes`` 均为空：早返回，wells 列表回显但不设液。"""
-    wells = _wells_grid("plate_slot2", ["A1", "A2"])
-    ret = handler._set_liquid_grouped_by_plate(
-        wells=wells,
-        liquid_names=[],
-        volumes=[],
-    )
-    # 不调用 set_liquids
-    assert all(w.liquid_history == [] for w in wells)
-    assert ret.volumes == []
-    # wells dump 仍返回输入列表
-    assert [w["name"] for w in ret.wells] == ["A1", "A2"]
-
-
-def test_grouped_by_plate_length_mismatch_raises(handler):
-    """wells / liquid_names / volumes 长度不一致应直接 raise（防御性校验）。"""
-    wells = _wells_grid("plate_slot2", ["A1", "A2"])
-    with pytest.raises(ValueError, match=r"必须等长"):
-        handler._set_liquid_grouped_by_plate(
-            wells=wells,
-            liquid_names=["r"] * 2,
-            volumes=[10.0],          # 长度 1，不匹配
-        )

tests/devices/liquid_handling/test_tip_reuse_by_liquid_name.py

@@ -1,566 +0,0 @@
-"""P10 v2 — Tip 复用 ``tracker.liquids`` 等价规则单元测试。
-
-测试覆盖（详见 ``product_designs/protocol_convert/10-tip-reuse-by-liquid-history.md`` §5）：
-
-    - Helper：``is_known_liquid_name`` / ``same_liquid_via_liquids`` /
-      ``same_liquid_via_liquids_pair`` / ``capture_tip_liquid_name``（4 helper
-      位于 ``liquid_history.py``，PLR-free 模块）。
-    - 单通道 transfer_liquid 主循环：identity-keep / liquids-keep / 配置开关 /
-      未知 name 保守换 tip / aspirate 顶层归零时序。
-    - 8 通道分支：段锚孔 liquids-keep。
-    - 跨节点边界：两个独立 transfer_liquid 调用状态隔离。
-
-helper 测试独立于 PLR，可在 ``pylabrobot`` 缺失环境下单独运行；端到端
-``transfer_liquid`` 主循环测试需要 PLR 环境（沿用 ``test_transfer_liquid.py`` 的
-``FakeLiquidHandler`` 模式：跳过 ``super().__init__``，仅 stub 4 类方法记录调用）。
-若 PLR import 失败则自动 skip 端到端测试，保留 helper 测试结果。
-"""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass, field
-from typing import Any, Iterable, List, Optional, Sequence, Tuple
-
-import pytest
-
-# P10 v2 helper 位于 PLR-free 模块，无论 pylabrobot 是否安装都能 import。
-from unilabos.devices.liquid_handling.liquid_history import (
-    capture_tip_liquid_name,
-    is_known_liquid_name,
-    same_liquid_via_liquids,
-    same_liquid_via_liquids_pair,
-)
-
-# 端到端测试依赖 PLR 完整环境；若 import 失败（例如本地 PLR 版本不匹配），
-# 整段端到端测试自动 skip，但 helper 测试照常执行。
-try:
-    from unilabos.devices.liquid_handling.liquid_handler_abstract import (
-        LiquidHandlerAbstract,
-    )
-
-    _PLR_AVAILABLE = True
-    _PLR_IMPORT_ERROR: Optional[Exception] = None
-except Exception as exc:  # pragma: no cover - 环境相关
-    LiquidHandlerAbstract = None  # type: ignore[assignment, misc]
-    _PLR_AVAILABLE = False
-    _PLR_IMPORT_ERROR = exc
-
-
-# ---------------------------------------------------------------------------
-# Fixtures：DummyTracker / DummyWell / DummyTipSpot / FakeLiquidHandler
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class DummyTracker:
-    """模拟 PLR ``VolumeTracker``：仅暴露 P10 v2 关心的 ``liquids`` 字段。"""
-
-    liquids: List[Tuple[Any, float]] = field(default_factory=list)
-    max_volume: float = 200.0
-    is_disabled: bool = False
-
-
-@dataclass
-class DummyWell:
-    """模拟 PLR ``Well``：仅暴露 ``tracker``。"""
-
-    name: str = "well"
-    tracker: DummyTracker = field(default_factory=DummyTracker)
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"DummyWell({self.name})"
-
-
-def make_well(name: str, liquid_name: Optional[str] = None, vol: float = 100.0) -> DummyWell:
-    """构造一个 well；若指定 ``liquid_name`` 则写入 ``tracker.liquids`` 顶层。"""
-    well = DummyWell(name=name, tracker=DummyTracker())
-    if liquid_name is not None:
-        well.tracker.liquids = [(liquid_name, vol)]
-    return well
-
-
-@dataclass(frozen=True)
-class DummyTipSpot:
-    name: str
-
-
-def make_tip_iter(n: int = 256) -> Iterable[List[DummyTipSpot]]:
-    for i in range(n):
-        yield [DummyTipSpot(f"tip_{i}")]
-
-
-# E2E 测试用的 base：PLR 可用时是 ``LiquidHandlerAbstract``，否则 fallback 到
-# ``object`` 让模块仍能 import；带 ``LiquidHandlerAbstract`` 的 e2e 测试用
-# ``skipif`` 跳过。
-_FakeBase = LiquidHandlerAbstract if _PLR_AVAILABLE else object
-
-
-class FakeLiquidHandler(_FakeBase):  # type: ignore[misc, valid-type]
-    """不初始化真实 backend/deck；仅记录 transfer_liquid 内部 4 类调用序列。
-
-    P10 v2 测试关心 ``pick_up_tips`` / ``discard_tips`` 的触发次数 + 顺序，
-    以推断 tip 是否被复用（一次 pick_up_tips 多次 aspirate/dispense → 复用）。
-    """
-
-    def __init__(self, channel_num: int = 1, tip_reuse_by_liquid_name: bool = True):
-        # 不调用 super().__init__，避免硬件 / ROS / PLR Deck 初始化。
-        self.channel_num = channel_num
-        self.support_touch_tip = True
-        self.current_tip = iter(make_tip_iter(2048))
-        self.calls: List[Tuple[str, Any]] = []
-        self._tip_reuse_by_liquid_name: bool = tip_reuse_by_liquid_name
-
-    def set_tiprack(self, tip_racks):
-        if not tip_racks:
-            return
-        # 跳过真实 set_tiprack（依赖 PLR Deck）
-        return
-
-    async def pick_up_tips(self, tip_spots, use_channels=None, offsets=None, **kw):
-        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)})
-        )
-
-    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)})
-        )
-
-    async def discard_tips(self, use_channels=None, *args, **kwargs):
-        self.calls.append(("discard_tips", {"use_channels": use_channels}))
-
-
-class AspiratePopFakeLiquidHandler(FakeLiquidHandler):
-    """T11 专用：aspirate 时模拟 PLR "顶层归零时 pop ``tracker.liquids`` 顶层" 的行为。
-
-    用于验证 P10 v2 的关键时序约束：tip name 必须在 aspirate **之前**预读，
-    否则 aspirate 后再读 ``tracker.liquids[-1]`` 会拿不到液体身份。
-    """
-
-    async def aspirate(self, resources, vols, **kwargs):
-        await super().aspirate(resources, vols, **kwargs)
-        # 模拟 PLR 顶层归零时 pop：对每个 source well，若 liquids 非空则 pop 顶层
-        for r in resources:
-            tracker = getattr(r, "tracker", None)
-            if tracker is not None and tracker.liquids:
-                tracker.liquids.pop()
-
-
-def run(coro):
-    return asyncio.run(coro)
-
-
-def call_names(lh: FakeLiquidHandler) -> List[str]:
-    return [c[0] for c in lh.calls]
-
-
-# ---------------------------------------------------------------------------
-# Helper 单元测试
-# ---------------------------------------------------------------------------
-
-
-class TestIsKnownLiquidName:
-    def test_empty_string_is_unknown(self) -> None:
-        assert is_known_liquid_name("") is False
-
-    def test_none_is_unknown(self) -> None:
-        assert is_known_liquid_name(None) is False
-
-    def test_literal_unknown_is_unknown(self) -> None:
-        assert is_known_liquid_name("unknown") is False
-        assert is_known_liquid_name("UNKNOWN") is False
-        assert is_known_liquid_name("  Unknown  ") is False
-
-    def test_literal_none_string_is_unknown(self) -> None:
-        assert is_known_liquid_name("none") is False
-        assert is_known_liquid_name("None") is False
-
-    def test_real_liquid_name_is_known(self) -> None:
-        assert is_known_liquid_name("PBS") is True
-        assert is_known_liquid_name("Tris HCl") is True
-        assert is_known_liquid_name("Liquid_3") is True
-
-
-class TestSameLiquidViaLiquids:
-    def test_well_and_tip_same_name_match(self) -> None:
-        well = make_well("A1", "PBS")
-        assert same_liquid_via_liquids(well, "PBS") is True
-
-    def test_well_and_tip_different_names_no_match(self) -> None:
-        well = make_well("A1", "PBS")
-        assert same_liquid_via_liquids(well, "Tris HCl") is False
-
-    def test_tip_unknown_returns_false(self) -> None:
-        well = make_well("A1", "PBS")
-        assert same_liquid_via_liquids(well, None) is False
-        assert same_liquid_via_liquids(well, "") is False
-        assert same_liquid_via_liquids(well, "unknown") is False
-
-    def test_well_empty_liquids_returns_false(self) -> None:
-        well = make_well("A1", liquid_name=None)  # 不写 liquids
-        assert same_liquid_via_liquids(well, "PBS") is False
-
-    def test_well_unknown_literal_returns_false(self) -> None:
-        well = make_well("A1", "unknown")
-        assert same_liquid_via_liquids(well, "unknown") is False
-
-
-class TestSameLiquidViaLiquidsPair:
-    def test_two_wells_same_name_match(self) -> None:
-        a = make_well("A1", "PBS")
-        b = make_well("B1", "PBS")
-        assert same_liquid_via_liquids_pair(a, b) is True
-
-    def test_two_wells_different_names_no_match(self) -> None:
-        a = make_well("A1", "PBS")
-        b = make_well("B1", "Tris HCl")
-        assert same_liquid_via_liquids_pair(a, b) is False
-
-    def test_either_well_empty_returns_false(self) -> None:
-        a = make_well("A1", "PBS")
-        b = make_well("B1", liquid_name=None)
-        assert same_liquid_via_liquids_pair(a, b) is False
-        assert same_liquid_via_liquids_pair(b, a) is False
-
-
-class TestCaptureTipLiquidName:
-    def test_known_name_returned(self) -> None:
-        well = make_well("A1", "PBS")
-        assert capture_tip_liquid_name(well) == "PBS"
-
-    def test_empty_well_returns_none(self) -> None:
-        well = make_well("A1", liquid_name=None)
-        assert capture_tip_liquid_name(well) is None
-
-    def test_unknown_literal_returns_none(self) -> None:
-        well = make_well("A1", "unknown")
-        assert capture_tip_liquid_name(well) is None
-
-
-# ---------------------------------------------------------------------------
-# T1–T12 端到端测试（单通道 transfer_liquid 主循环）
-#
-# 需要 PLR 完整环境（``pylabrobot.liquid_handling.LiquidHandlerBackend`` 等）。
-# 若 PLR import 失败则整段 skip，helper 测试照常运行。
-# ---------------------------------------------------------------------------
-
-_skip_if_no_plr = pytest.mark.skipif(
-    not _PLR_AVAILABLE,
-    reason=f"pylabrobot import failed: {_PLR_IMPORT_ERROR}",
-)
-
-
-@_skip_if_no_plr
-class TestSingleChannelTipReuse:
-    """覆盖 §5 矩阵 T1 / T2 / T3 / T4 / T5 / T6 / T8 / T10 / T11。"""
-
-    def test_T1_identity_hit_reuses_tip(self) -> None:
-        """T1：连续 2 轮同 source/target → identity-keep 命中，复用 tip。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        src = make_well("S0", "PBS")
-        tgt = make_well("T0")
-        run(
-            lh.transfer_liquid(
-                sources=[src, src],
-                targets=[tgt, tgt],
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1],
-            )
-        )
-        # 2 次 transfer，但 identity-keep → 仅 1 次 pick_up_tips / 1 次 discard_tips
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-        assert call_names(lh).count("aspirate") == 2
-        assert call_names(lh).count("dispense") == 2
-
-    def test_T2_liquids_hit_across_plates(self) -> None:
-        """T2：9 个独立 source well（不同 PLR Well 对象）都装 PBS → identity 全 fail，liquids-keep 全命中。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        sources = [make_well(f"S{i}", "PBS") for i in range(9)]
-        targets = [make_well(f"T{i}") for i in range(9)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1] * 9,
-                dis_vols=[1] * 9,
-            )
-        )
-        # 9 个 source 物理上同液 → 整段共用 1 个 tip
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-        assert call_names(lh).count("aspirate") == 9
-        assert call_names(lh).count("dispense") == 9
-
-    def test_T3_liquids_hit_same_plate_different_wells(self) -> None:
-        """T3：同 plate 上 A1-H1 都装 PBS（8 个不同 Well 对象）→ identity 全 fail，liquids-keep 命中。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        sources = [make_well(f"A{i}", "PBS") for i in range(1, 9)]
-        targets = [make_well(f"T{i}") for i in range(8)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1] * 8,
-                dis_vols=[1] * 8,
-            )
-        )
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-
-    def test_T4_liquids_not_match_forces_tip_change(self) -> None:
-        """T4：A1=PBS，B1=Tris HCl → liquids 名不等，强制换 tip。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        sources = [make_well("A1", "PBS"), make_well("B1", "Tris HCl")]
-        targets = [make_well("T0"), make_well("T1")]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1],
-            )
-        )
-        # 2 次完全独立的 transfer：2 次 pick_up / 2 次 discard
-        assert call_names(lh).count("pick_up_tips") == 2
-        assert call_names(lh).count("discard_tips") == 2
-
-    def test_T5_empty_liquids_forces_tip_change(self) -> None:
-        """T5：source 从未调过 set_liquids（liquids 空）→ 视为未知，强制换 tip。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        sources = [make_well("A1"), make_well("B1")]  # 没装液体名
-        targets = [make_well("T0"), make_well("T1")]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1],
-            )
-        )
-        assert call_names(lh).count("pick_up_tips") == 2
-        assert call_names(lh).count("discard_tips") == 2
-
-    def test_T6_switch_off_disables_liquids_keep(self) -> None:
-        """T6：tip_reuse_by_liquid_name=False，T2 场景退化为 identity-only，强制换 tip。"""
-        lh = FakeLiquidHandler(channel_num=1, tip_reuse_by_liquid_name=False)
-        sources = [make_well(f"S{i}", "PBS") for i in range(9)]
-        targets = [make_well(f"T{i}") for i in range(9)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1] * 9,
-                dis_vols=[1] * 9,
-            )
-        )
-        # 关闭开关后 → 退化为 identity-only，9 次独立换 tip
-        assert call_names(lh).count("pick_up_tips") == 9
-        assert call_names(lh).count("discard_tips") == 9
-
-    def test_T8_mix_style_same_source_reuses_via_identity(self) -> None:
-        """T8：单 source 反复 aspirate/dispense → identity-keep 命中（mix-style）。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        src = make_well("S0", "Methanol")
-        tgt = make_well("T0")
-        run(
-            lh.transfer_liquid(
-                sources=[src, src, src],
-                targets=[tgt, tgt, tgt],
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1, 1],
-                dis_vols=[1, 1, 1],
-            )
-        )
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-
-    def test_T10_unknown_literal_treated_as_unknown(self) -> None:
-        """T10：``tracker.liquids = [("unknown", v)]``（兼容旧数据）→ 视为未知，强制换 tip。"""
-        lh = FakeLiquidHandler(channel_num=1)
-        sources = [make_well("A1", "unknown"), make_well("B1", "unknown")]
-        targets = [make_well("T0"), make_well("T1")]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1, 1],
-                dis_vols=[1, 1],
-            )
-        )
-        assert call_names(lh).count("pick_up_tips") == 2
-        assert call_names(lh).count("discard_tips") == 2
-
-    def test_T11_aspirate_pop_timing_pre_read(self) -> None:
-        """T11：aspirate 顶层归零 → PLR pop ``tracker.liquids`` 顶层；
-        验证 P10 v2 ``pending_tip_name`` 必须在 aspirate **之前**预读才能命中下一轮。
-        """
-        lh = AspiratePopFakeLiquidHandler(channel_num=1)
-        sources = [make_well(f"S{i}", "PBS") for i in range(3)]
-        targets = [make_well(f"T{i}") for i in range(3)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1] * 3,
-                dis_vols=[1] * 3,
-            )
-        )
-        # 即使 aspirate 后 source.tracker.liquids 被 pop，pending_tip_name 已捕获 "PBS"
-        # → 下一轮 source 仍是 PBS（aspirate 还没发生），liquids-keep 命中
-        # → 整段 1 次 pick_up_tips
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-
-
-# ---------------------------------------------------------------------------
-# T7：跨节点边界（两个独立 transfer_liquid 调用，状态隔离）
-# ---------------------------------------------------------------------------
-
-
-@_skip_if_no_plr
-class TestCrossNodeBoundary:
-    """T7：两个 transfer_liquid 节点之间不复用 tip（每次调用初始化 current_tip_liquid_name=None）。"""
-
-    def test_T7_two_calls_dont_share_tip_state(self) -> None:
-        lh = FakeLiquidHandler(channel_num=1)
-        src_a = make_well("A_src", "PBS")
-        tgt_a = make_well("A_tgt")
-        src_b = make_well("B_src", "PBS")  # 同名液，但不同 well
-        tgt_b = make_well("B_tgt")
-
-        run(
-            lh.transfer_liquid(
-                sources=[src_a],
-                targets=[tgt_a],
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1],
-                dis_vols=[1],
-            )
-        )
-        run(
-            lh.transfer_liquid(
-                sources=[src_b],
-                targets=[tgt_b],
-                tip_racks=[],
-                use_channels=[0],
-                asp_vols=[1],
-                dis_vols=[1],
-            )
-        )
-        # 两次调用各自独立换 tip → 2 次 pick_up_tips / 2 次 discard_tips
-        assert call_names(lh).count("pick_up_tips") == 2
-        assert call_names(lh).count("discard_tips") == 2
-
-
-# ---------------------------------------------------------------------------
-# T9：8 通道段锚孔 liquids-keep
-# ---------------------------------------------------------------------------
-
-
-@_skip_if_no_plr
-class TestEightChannelSegmentTipReuse:
-    """T9：8 通道分段，连续两段 src_slice[0] 同名 → 段间不换 tip。"""
-
-    def test_T9_two_segments_same_anchor_liquid(self) -> None:
-        lh = FakeLiquidHandler(channel_num=8)
-        # 16 个 source wells，分 2 段；段 1 锚孔 = sources[0]，段 2 锚孔 = sources[8]
-        sources = [make_well(f"S{i}", "PBS") for i in range(16)]
-        targets = [make_well(f"T{i}") for i in range(16)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=list(range(8)),
-                asp_vols=[1] * 16,
-                dis_vols=[1] * 16,
-                mix_times=0,
-            )
-        )
-        # 2 段都同液 → liquids-keep 命中 → 仅 1 次 pick_up_tips
-        assert call_names(lh).count("pick_up_tips") == 1
-        assert call_names(lh).count("discard_tips") == 1
-
-    def test_T9b_two_segments_different_anchor_liquid_forces_tip_change(self) -> None:
-        """T9b：段 1 锚孔 = PBS，段 2 锚孔 = Tris → 段间强制换 tip。"""
-        lh = FakeLiquidHandler(channel_num=8)
-        seg1 = [make_well(f"S{i}", "PBS") for i in range(8)]
-        seg2 = [make_well(f"S{i + 8}", "Tris HCl") for i in range(8)]
-        sources = seg1 + seg2
-        targets = [make_well(f"T{i}") for i in range(16)]
-        run(
-            lh.transfer_liquid(
-                sources=sources,
-                targets=targets,
-                tip_racks=[],
-                use_channels=list(range(8)),
-                asp_vols=[1] * 16,
-                dis_vols=[1] * 16,
-                mix_times=0,
-            )
-        )
-        # 2 段不同液 → 2 次独立换 tip
-        assert call_names(lh).count("pick_up_tips") == 2
-        assert call_names(lh).count("discard_tips") == 2
-
-
-# ---------------------------------------------------------------------------
-# 配置开关默认值 / 实例字段读取
-# ---------------------------------------------------------------------------
-
-
-@_skip_if_no_plr
-class TestConfigDefault:
-    def test_default_switch_is_on(self) -> None:
-        """默认 ``_tip_reuse_by_liquid_name`` 应为 True（测试 fixture 显式 default 一致）。"""
-        lh = FakeLiquidHandler()
-        assert lh._tip_reuse_by_liquid_name is True
-
-    def test_switch_off_takes_effect(self) -> None:
-        lh = FakeLiquidHandler(tip_reuse_by_liquid_name=False)
-        assert lh._tip_reuse_by_liquid_name is False

tests/devices/liquid_handling/test_transfer_liquid.py

@@ -39,11 +39,6 @@ class FakeLiquidHandler(LiquidHandlerAbstract):
         self.current_tip = iter(make_tip_iter())
         self.calls: List[Tuple[str, Any]] = []
 
-    def set_tiprack(self, tip_racks):
-        if not tip_racks:
-            return
-        super().set_tiprack(tip_racks)
-
     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}))
 

tests/devices/liquid_handling/unit_test.py

@@ -1,608 +0,0 @@
-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]] = []
-
-    def set_tiprack(self, tip_racks):
-        # transfer_liquid 总会调用 set_tiprack；测试用 Dummy 枪头时 tip_racks 为空，需保留自种子的 current_tip
-        if not tip_racks:
-            return
-        super().set_tiprack(tip_racks)
-
-    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]]
-
-
-def test_set_tiprack_per_type_resumes_first_physical_rack():
-    """同型号多次 set_tiprack 时接续第一盒剩余孔位，而非从新盒 A1 开始。"""
-    from pylabrobot.liquid_handling import LiquidHandlerChatterboxBackend
-    from pylabrobot.resources import Deck, Tip, TipRack, TipSpot, create_equally_spaced
-
-    mk = lambda: Tip(
-        has_filter=False, total_tip_length=10.0, maximal_volume=300.0, fitting_depth=2.0
-    )
-
-    class TipTypeAlpha(TipRack):
-        pass
-
-    class TipTypeBeta(TipRack):
-        pass
-
-    def make_rack(cls: type, name: str) -> TipRack:
-        items = create_equally_spaced(
-            TipSpot,
-            num_items_x=12,
-            num_items_y=2,
-            dx=0,
-            dy=0,
-            dz=0,
-            item_dx=9,
-            item_dy=9,
-            size_x=1,
-            size_y=1,
-            make_tip=mk,
-        )
-        return cls(name, 120, 40, 10, items=items)
-
-    rack1 = make_rack(TipTypeAlpha, "rack_phys_1")
-    rack2 = make_rack(TipTypeBeta, "rack_phys_2")
-    rack3 = make_rack(TipTypeAlpha, "rack_phys_3")
-
-    lh = LiquidHandlerAbstract(
-        LiquidHandlerChatterboxBackend(1), Deck(), channel_num=1, simulator=False
-    )
-    flat1 = lh._flatten_tips_from_one(rack1)
-    assert len(flat1) == 24
-
-    lh.set_tiprack([rack1])
-    for i in range(12):
-        assert lh._get_next_tip() is flat1[i]
-
-    lh.set_tiprack([rack2])
-    spot_b = lh._get_next_tip()
-    assert "rack_phys_2" in spot_b.name
-
-    lh.set_tiprack([rack3])
-    spot_resume = lh._get_next_tip()
-    assert spot_resume is flat1[12], "第三次同型号应接续 rack1 第二行首孔，而非 rack3 首孔"
-    assert spot_resume is not lh._flatten_tips_from_one(rack3)[0]
-
-

tests/resources/test_resource_tracker_history.py

@@ -1,137 +0,0 @@
-"""P9 — ``_augment_states_with_liquid_history`` 单元测试（OS→Cloud sync 链路 Phase C）。
-
-详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md`` §6.3 / §8 T4。
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List
-
-import pytest
-
-from unilabos.resources.resource_tracker import _augment_states_with_liquid_history
-
-
-# ---------------------------------------------------------------------------
-# Fixtures：纯 dataclass 模拟 PLR 资源树（避免引入 PLR 真实实例化）
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class FakeTracker:
-    liquid_history: Any = field(default_factory=list)
-
-
-@dataclass
-class FakeResource:
-    name: str
-    tracker: Any = None
-    children: List["FakeResource"] = field(default_factory=list)
-
-
-# ---------------------------------------------------------------------------
-# Tests
-# ---------------------------------------------------------------------------
-
-
-class TestAugmentStatesWithLiquidHistory:
-    def test_single_well_history_attached(self) -> None:
-        well = FakeResource("well_A1", tracker=FakeTracker(liquid_history=[
-            {"name": "Plasma", "volume": 100, "action": "set"}
-        ]))
-        states: Dict[str, Any] = {"well_A1": {"liquids": [], "pending_liquids": []}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        assert "liquid_history" in states["well_A1"]
-        assert states["well_A1"]["liquid_history"] == [
-            {"name": "Plasma", "volume": 100, "action": "set"}
-        ]
-
-    def test_recursive_walk_attaches_to_all_wells(self) -> None:
-        """resource 树有多层时，每个有 tracker 的节点都会被并入 states。"""
-        wells = [
-            FakeResource(f"well_{i}", tracker=FakeTracker(liquid_history=[
-                {"name": f"L_{i}", "volume": i * 10, "action": "set"}
-            ]))
-            for i in range(3)
-        ]
-        plate = FakeResource("plate", children=wells)
-        deck = FakeResource("deck", children=[plate])
-        states: Dict[str, Any] = {
-            "deck": {"liquids": []},
-            "plate": {"liquids": []},
-            "well_0": {"liquids": []},
-            "well_1": {"liquids": []},
-            "well_2": {"liquids": []},
-        }
-
-        _augment_states_with_liquid_history(deck, states)
-
-        assert states["well_0"]["liquid_history"] == [{"name": "L_0", "volume": 0, "action": "set"}]
-        assert states["well_1"]["liquid_history"] == [{"name": "L_1", "volume": 10, "action": "set"}]
-        assert states["well_2"]["liquid_history"] == [{"name": "L_2", "volume": 20, "action": "set"}]
-
-    def test_no_tracker_node_skipped(self) -> None:
-        """没有 tracker 的节点（如 deck 自身）跳过，state dict 不被污染。"""
-        deck = FakeResource("deck")  # tracker=None
-        states: Dict[str, Any] = {"deck": {"some_field": 1}}
-
-        _augment_states_with_liquid_history(deck, states)
-
-        assert "liquid_history" not in states["deck"]
-
-    def test_existing_liquid_history_in_state_not_overwritten(self) -> None:
-        """state 已经有 liquid_history 字段（例如 PLR 升级未来支持了）→ 不覆盖。"""
-        well = FakeResource("well_A1", tracker=FakeTracker(liquid_history=[
-            {"name": "Plasma", "volume": 100, "action": "set"}
-        ]))
-        states: Dict[str, Any] = {"well_A1": {"liquid_history": ["preexisting"]}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        assert states["well_A1"]["liquid_history"] == ["preexisting"]
-
-    def test_history_is_shallow_copied(self) -> None:
-        """augment 后的 history 应是独立 list（避免运行时 mutate 污染 dump 结果）。"""
-        original_history = [{"name": "X", "volume": 1, "action": "set"}]
-        well = FakeResource("well_A1", tracker=FakeTracker(liquid_history=original_history))
-        states: Dict[str, Any] = {"well_A1": {}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        # mutate runtime history 不应反映到 augmented state
-        original_history.append({"name": "Y", "volume": 2, "action": "set"})
-        assert len(states["well_A1"]["liquid_history"]) == 1
-
-    def test_node_not_in_states_silently_skipped(self) -> None:
-        """resource 树中的节点 name 不在 ``states`` 字典里 → 静默跳过。"""
-        well = FakeResource("well_orphan", tracker=FakeTracker(liquid_history=[
-            {"name": "X", "volume": 1, "action": "set"}
-        ]))
-        states: Dict[str, Any] = {"well_A1": {}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        # 不应该新增 well_orphan 键，也不应污染 well_A1
-        assert "well_orphan" not in states
-        assert "liquid_history" not in states["well_A1"]
-
-    def test_non_list_liquid_history_skipped(self) -> None:
-        """tracker.liquid_history 非 list 时（异常情况）→ 跳过，不写入 state。"""
-        well = FakeResource("well_A1", tracker=FakeTracker(liquid_history="broken"))
-        states: Dict[str, Any] = {"well_A1": {}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        assert "liquid_history" not in states["well_A1"]
-
-    def test_empty_history_still_written(self) -> None:
-        """tracker.liquid_history = [] 是合法状态 → 应写入空 list（表示"未有任何液体操作"）。"""
-        well = FakeResource("well_A1", tracker=FakeTracker(liquid_history=[]))
-        states: Dict[str, Any] = {"well_A1": {}}
-
-        _augment_states_with_liquid_history(well, states)
-
-        assert states["well_A1"]["liquid_history"] == []

tests/workflow/test_build_protocol_graph_target_device.py

@@ -1,351 +0,0 @@
-"""P6.1 / P6.1.1 `build_protocol_graph` 集成测试 —— 对应 06-labware-mapping-table.md §11.7.7 C / §11.8.7 C。
-
-6 条用例：
-
-- `test_build_graph_default_target_device_prcxi` —— 不传 target_device 时默认 "prcxi"，
-  与 P6 等价（PRCXI_* class_name）。
-- `test_build_graph_explicit_target_device_prcxi` —— 显式 "prcxi" 与默认完全等价。
-- `test_build_graph_target_device_unknown_falls_back_to_default_section` —— 未声明的
-  target_device 由 loader 自动 fallback 到 ``target_devices.default``；第一版 default
-  段按 prcxi 拷贝，所以结果应与 "prcxi" 完全一致。
-- `test_build_graph_per_device_tip_class` —— 临时 YAML 同时声明 prcxi 与 beckman tip
-  量程档；同一 transfer_liquid 在 target_device="prcxi" / "beckman" 下命中不同 class。
-- `test_field_renamed_target_class_name` —— `labware_info` 写入的字段是
-  `target_class_name`，**旧字段 `prcxi_class_name` 不存在**。
-- `test_build_graph_model_level_slot_remap` —— P6.1.1：``target_model`` 透传到
-  ``_map_deck_slot`` 后改变 create_resource 的 slot（同厂商不同型号 deck 物理布局不同）。
-
-本测试在导入 common.py 之前 mock 掉 matplotlib / networkx.drawing.nx_agraph，避免在
-没有图形依赖的最小 Python 环境下也能跑（与 P6 批量回归脚本同样的策略）。
-"""
-from __future__ import annotations
-
-import sys
-import types
-import warnings
-from pathlib import Path
-
-import pytest
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-
-def _install_fake_optional_deps() -> None:
-    """安装 matplotlib / networkx.drawing.nx_agraph 的 fake 实现，避免本地环境硬依赖。
-
-    common.py 在模块级 import 这些库做可视化辅助；build_protocol_graph 主路径不会真用到。
-    fake 模块只需要满足 ``from X import Y`` 的查找即可。
-    """
-    if "matplotlib" not in sys.modules:
-        fake_matplotlib = types.ModuleType("matplotlib")
-        sys.modules["matplotlib"] = fake_matplotlib
-    if "matplotlib.pyplot" not in sys.modules:
-        fake_plt = types.ModuleType("matplotlib.pyplot")
-        sys.modules["matplotlib.pyplot"] = fake_plt
-    # networkx.drawing.nx_agraph.to_agraph 依赖 pygraphviz；不可用时给个空 stub
-    try:
-        from networkx.drawing import nx_agraph  # noqa: F401
-    except Exception:
-        nx_drawing = types.ModuleType("networkx.drawing")
-        nx_agraph_mod = types.ModuleType("networkx.drawing.nx_agraph")
-
-        def _to_agraph(_g):  # type: ignore[no-untyped-def]
-            raise RuntimeError("nx_agraph fake — not used in build_protocol_graph main path")
-
-        nx_agraph_mod.to_agraph = _to_agraph  # type: ignore[attr-defined]
-        nx_drawing.nx_agraph = nx_agraph_mod  # type: ignore[attr-defined]
-        sys.modules["networkx.drawing"] = nx_drawing
-        sys.modules["networkx.drawing.nx_agraph"] = nx_agraph_mod
-
-
-_install_fake_optional_deps()
-
-from unilabos.workflow import labware_mapping as lm  # noqa: E402
-from unilabos.workflow.common import build_protocol_graph  # noqa: E402
-
-
-@pytest.fixture(autouse=True)
-def _reset_mapping_cache():
-    """每个用例后清 lru_cache，避免跨用例污染。"""
-    yield
-    lm.reload_mapping()
-
-
-# ==================== 公共 fixture：最小 transfer_liquid 协议 ====================
-
-
-def _minimal_labware_info() -> dict:
-    """返回最小可用的 labware_info（mutable，每个 case 独立 build 一份）。
-
-    包含 tip rack + 24-tube rack + 96 wellplate（slot 1/2/3），覆盖 P6.1 主要 kind。
-    tube rack / plate 显式声明 ``num_wells``，避免在无 labware_defs / 无 prcxi_labware 模板
-    时通过 well-count 启发式（well_n=3）误判孔数；与真实协议中 labware_defs 提供 num_wells
-    的行为对齐。
-    """
-    return {
-        "tips": {
-            "slot": 1,
-            "well": [],
-            "labware": "opentrons_96_tiprack_300ul",
-            "object": "tiprack",
-        },
-        "samples": {
-            "slot": 2,
-            "well": ["A1", "A2", "A3"],
-            "labware": "opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap",
-            "object": "source",
-            "num_wells": 24,
-        },
-        "plate_target": {
-            "slot": 3,
-            "well": ["A1", "A2", "A3"],
-            "labware": "opentrons_96_wellplate_300ul_pcr",
-            "object": "target",
-            "num_wells": 96,
-        },
-    }
-
-
-def _minimal_protocol_steps() -> list:
-    """最小 transfer_liquid 协议步骤：asp_vols/dis_vols 最大 200 µL → PRCXI 300ul 档。"""
-    return [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "samples",
-                "targets": "plate_target",
-                "tip_racks": "tips",
-                "asp_vols": [200.0, 200.0, 200.0],
-                "dis_vols": [200.0, 200.0, 200.0],
-            },
-            "step_number": 1,
-        }
-    ]
-
-
-def _collect_create_resource_classes(graph) -> dict:
-    """从工作流图中提取每个 create_resource 节点的 ``slot_on_deck → class_name``。"""
-    out: dict = {}
-    for _nid, node in graph.nodes.items():
-        if node.get("template_name") != "create_resource":
-            continue
-        param = node.get("param") or {}
-        slot = str(param.get("slot_on_deck") or "")
-        cls = str(param.get("class_name") or "")
-        if slot:
-            out[slot] = cls
-    return out
-
-
-# ==================== 5 条核心用例 ====================
-
-
-def test_build_graph_default_target_device_prcxi():
-    """不传 target_device → 默认 "prcxi" → 与 P6 等价（PRCXI_* class_name）。"""
-    labware_info = _minimal_labware_info()
-    g = build_protocol_graph(
-        labware_info=labware_info,
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-    )
-    classes = _collect_create_resource_classes(g)
-    assert classes["1"] == "PRCXI_300ul_Tips"           # 200 µL → 300 档
-    assert classes["2"] == "PRCXI_EP_Adapter"            # 24-tube rack
-    assert classes["3"] == "PRCXI_BioER_96_wellplate"    # 96 wellplate
-
-
-def test_build_graph_explicit_target_device_prcxi():
-    """显式传 target_device="prcxi" 应与默认完全等价。"""
-    labware_info_a = _minimal_labware_info()
-    labware_info_b = _minimal_labware_info()
-    g_default = build_protocol_graph(
-        labware_info=labware_info_a,
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-    )
-    g_prcxi = build_protocol_graph(
-        labware_info=labware_info_b,
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-        target_device="prcxi",
-    )
-    assert _collect_create_resource_classes(g_default) == _collect_create_resource_classes(g_prcxi)
-
-
-def test_build_graph_target_device_unknown_falls_back_to_default_section():
-    """未声明的 target_device → loader 自动 fallback 到固定段 target_devices.default + warning。
-
-    第一版 default 段按 prcxi 拷贝填充 → 结果应与 target_device="prcxi" 完全等价（PRCXI_*）。
-    """
-    labware_info_a = _minimal_labware_info()
-    labware_info_b = _minimal_labware_info()
-    g_prcxi = build_protocol_graph(
-        labware_info=labware_info_a,
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-        target_device="prcxi",
-    )
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        g_unknown = build_protocol_graph(
-            labware_info=labware_info_b,
-            protocol_steps=_minimal_protocol_steps(),
-            workstation_name="PRCXI",
-            target_device="unknown_xxx",
-        )
-    assert _collect_create_resource_classes(g_unknown) == _collect_create_resource_classes(g_prcxi)
-    # loader 至少打 1 次 warning 提示「未声明、已回退到 default」
-    assert any(
-        ("未在 labware_mapping.yaml" in str(w.message))
-        or ("target_devices.default" in str(w.message))
-        for w in caught
-    )
-
-
-def test_build_graph_per_device_tip_class(tmp_path, monkeypatch):
-    """同一 protocol，target_device="prcxi" / "beckman" 在 200µL 下命中不同 tip 档（P6.1.1 schema）。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds:\n'
-        '  - {pattern: "trash", kind: trash}\n'
-        '  - {pattern: "tiprack|tip[_ ]?rack|opentrons_\\\\d+_tiprack", kind: tip_rack}\n'
-        '  - {pattern: "tuberack|tube[_ ]rack|eppendorf.*rack|safelock.*rack", kind: tube_rack}\n'
-        '  - {pattern: ".*", kind: plate}\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13", "8": "14"}, by_object: {trash: {"12": "16"}}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96,                    class_name: PRCXI_1000uL_Tips}\n'
-        '      - {kind: tube_rack, hole_count: 24, class_name: PRCXI_EP_Adapter}\n'
-        '      - {kind: plate,     hole_count: 96, class_name: PRCXI_BioER_96_wellplate}\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13", "8": "14"}, by_object: {trash: {"12": "16"}}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96,                    class_name: PRCXI_1000uL_Tips}\n'
-        '      - {kind: tube_rack, hole_count: 24, class_name: PRCXI_EP_Adapter}\n'
-        '      - {kind: plate,     hole_count: 96, class_name: PRCXI_BioER_96_wellplate}\n'
-        '  beckman:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {trash: {"12": "16"}}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 20,    class_name: Beckman_20uL_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96, volume_max: 199.9, class_name: Beckman_200uL_Tips}\n'
-        '      - {kind: tip_rack,  hole_count: 96,                    class_name: Beckman_1000uL_Tips}\n'
-        '      - {kind: tube_rack, hole_count: 24, class_name: Beckman_24_TubeRack}\n'
-        '      - {kind: plate,     hole_count: 96, class_name: Beckman_BioMek_96_wellplate}\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-
-    g_prcxi = build_protocol_graph(
-        labware_info=_minimal_labware_info(),
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-        target_device="prcxi",
-    )
-    g_beckman = build_protocol_graph(
-        labware_info=_minimal_labware_info(),
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-        target_device="beckman",
-    )
-
-    classes_prcxi = _collect_create_resource_classes(g_prcxi)
-    classes_beckman = _collect_create_resource_classes(g_beckman)
-
-    # 200 µL：prcxi 走 300 档；beckman 200 档已超 → 1000 档
-    assert classes_prcxi["1"] == "PRCXI_300ul_Tips"
-    assert classes_beckman["1"] == "Beckman_1000uL_Tips"
-    # plate / tube rack 也按 target_device 输出对应厂商类
-    assert classes_prcxi["2"] == "PRCXI_EP_Adapter"
-    assert classes_beckman["2"] == "Beckman_24_TubeRack"
-    assert classes_prcxi["3"] == "PRCXI_BioER_96_wellplate"
-    assert classes_beckman["3"] == "Beckman_BioMek_96_wellplate"
-
-
-def test_field_renamed_target_class_name():
-    """`labware_info` 写入的字段是 `target_class_name`；旧字段 `prcxi_class_name` 不存在。"""
-    labware_info = _minimal_labware_info()
-    build_protocol_graph(
-        labware_info=labware_info,
-        protocol_steps=_minimal_protocol_steps(),
-        workstation_name="PRCXI",
-    )
-    for lid, item in labware_info.items():
-        assert "target_class_name" in item, f"{lid!r} 缺少 target_class_name 字段"
-        assert "prcxi_class_name" not in item, f"{lid!r} 残留了旧字段 prcxi_class_name"
-        assert item["target_class_name"], f"{lid!r} target_class_name 为空"
-
-
-# ==================== P6.1.1 新增集成测试 ====================
-
-
-def _labware_info_slot4_plate() -> dict:
-    """slot=4 的 96 板：用来验证 target_model 透传后 slot_remap 改变 create_resource 的槽位。"""
-    return {
-        "plate_slot4": {
-            "slot": 4,
-            "well": ["A1"],
-            "labware": "opentrons_96_wellplate_300ul_pcr",
-            "object": "target",
-            "num_wells": 96,
-        },
-    }
-
-
-def test_build_graph_model_level_slot_remap(tmp_path, monkeypatch):
-    """P6.1.1：target_model 透传到 _map_deck_slot 后改变 create_resource 的 slot_on_deck。
-
-    YAML 中 prcxi 厂商级 slot_remap 4→13；模型 "4040" 显式覆盖 4→16。
-    同一份 labware_info（slot=4）build 出的两份图，slot_on_deck 应分别为 "13" 与 "16"。
-    """
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: [{kind: plate, hole_count: 96, class_name: PRCXI_BioER_96_wellplate}]\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: [{kind: plate, hole_count: 96, class_name: PRCXI_BioER_96_wellplate}]\n'
-        '    models:\n'
-        '      "4040":\n'
-        '        slot_remap: {default: {"4": "16"}, by_object: {}}\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-
-    g_default = build_protocol_graph(
-        labware_info=_labware_info_slot4_plate(),
-        protocol_steps=[],
-        workstation_name="PRCXI",
-        target_device="prcxi",
-    )
-    g_model_4040 = build_protocol_graph(
-        labware_info=_labware_info_slot4_plate(),
-        protocol_steps=[],
-        workstation_name="PRCXI",
-        target_device="prcxi",
-        target_model="4040",
-    )
-
-    classes_default = _collect_create_resource_classes(g_default)
-    classes_4040 = _collect_create_resource_classes(g_model_4040)
-
-    # 厂商级（无 model）→ slot 4 → "13"
-    assert "13" in classes_default, f"未找到 slot 13，实际生成的 slots: {list(classes_default)}"
-    assert "16" not in classes_default
-    # 模型 4040 → slot 4 → "16"
-    assert "16" in classes_4040, f"未找到 slot 16，实际生成的 slots: {list(classes_4040)}"
-    assert "13" not in classes_4040
-    # class_name 不变（rules 继承厂商级）
-    assert classes_default["13"] == "PRCXI_BioER_96_wellplate"
-    assert classes_4040["16"] == "PRCXI_BioER_96_wellplate"

tests/workflow/test_common_cross_slot_v2.py

@@ -1,369 +0,0 @@
-"""P2 v2 跨 slot transfer_liquid 合并 —— Stage 3 (`workflow/common.py`) 集成测试。
-
-对应 ``product_designs/protocol_convert/02-cross-slot-merge.md`` §9.5 step 6.2。
-
-v2 设计要点（与本测试用例的映射）
------------------------------------
-当 transfer_liquid 节点 ``params.targets`` 是 ``list[str]`` 时，``build_protocol_graph``
-在该 transfer_liquid 之前**插入一个 merged ``set_liquid_from_plate`` 节点**：
-
-- merged 节点的 ``param.wells`` 是按 ``params.targets`` 顺序通过 cursor 拼出来的有序跨板
-  well refs（每个元素是 ``{id, name, parent: reagent_key, type: "well"}``）。
-- merged 节点接收来自每个涉及 plate 的 ``create_resource`` 节点的多入边
-  (``labware`` → ``wells_identifier``)。
-- merged 节点的 ``output_wells`` 通过**单条边**连到 transfer_liquid 的 ``targets_identifier``。
-- transfer_liquid 节点的 ``params.targets`` 被改写为 synthetic key
-  ``_merged_targets_<idx>``（runtime 不消费 list 形态），保证 INPUT_PORT_MAPPING 走单边路径。
-
-用例
-----
-- ``test_emit_merged_set_liquid_basic`` — 4 个 distinct reagent_key（51b9a5 主场景）。
-- ``test_emit_merged_set_liquid_repeat_key`` — 同 reagent_key 重复（同板多孔）。
-- ``test_emit_merged_set_liquid_mixed`` — 跨板混合 + 同板重复（cursor 推进）。
-- ``test_emit_merged_set_liquid_8ch`` — 与 P1 multi-channel 复合（8 通道 cross-slot）。
-- ``test_transfer_liquid_targets_rewrite`` — transfer_liquid 节点改写后只剩 1 条
-  ``targets_identifier`` 入边；params.targets 不再是 list。
-"""
-from __future__ import annotations
-
-import sys
-import types
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-
-def _install_fake_optional_deps() -> None:
-    """与 test_build_protocol_graph_target_device.py 一致的可选依赖 stub。"""
-    if "matplotlib" not in sys.modules:
-        sys.modules["matplotlib"] = types.ModuleType("matplotlib")
-    if "matplotlib.pyplot" not in sys.modules:
-        sys.modules["matplotlib.pyplot"] = types.ModuleType("matplotlib.pyplot")
-    try:
-        from networkx.drawing import nx_agraph  # noqa: F401
-    except Exception:
-        nx_drawing = types.ModuleType("networkx.drawing")
-        nx_agraph_mod = types.ModuleType("networkx.drawing.nx_agraph")
-        nx_agraph_mod.to_agraph = lambda _g: None  # type: ignore[attr-defined]
-        nx_drawing.nx_agraph = nx_agraph_mod  # type: ignore[attr-defined]
-        sys.modules["networkx.drawing"] = nx_drawing
-        sys.modules["networkx.drawing.nx_agraph"] = nx_agraph_mod
-
-
-_install_fake_optional_deps()
-
-import pytest  # noqa: E402
-
-from unilabos.workflow.common import build_protocol_graph  # noqa: E402
-
-
-# ==================== 测试辅助：从工作流图中提取节点/边 ====================
-
-
-def _nodes_by_template(graph, template_name: str) -> List[Dict[str, Any]]:
-    return [
-        {"id": nid, **node}
-        for nid, node in graph.nodes.items()
-        if node.get("template_name") == template_name
-    ]
-
-
-def _create_resource_by_slot(graph) -> Dict[str, str]:
-    """slot_on_deck (str) -> create_resource 节点 ID。"""
-    out: Dict[str, str] = {}
-    for nid, node in graph.nodes.items():
-        if node.get("template_name") == "create_resource":
-            slot = str(node.get("param", {}).get("slot_on_deck") or "")
-            if slot:
-                out[slot] = nid
-    return out
-
-
-def _edges_to(graph, target_id: str) -> List[Dict[str, Any]]:
-    return [e for e in graph.edges if e["target"] == target_id]
-
-
-def _edges_from(graph, source_id: str) -> List[Dict[str, Any]]:
-    return [e for e in graph.edges if e["source"] == source_id]
-
-
-# ==================== fixture：构造跨板 labware + steps ====================
-
-
-def _cross_slot_labware_info() -> Dict[str, Dict[str, Any]]:
-    """51b9a5 简化：slot1 source + slot2/3/5/6 target plates + slot12 tip。"""
-    return {
-        "l1": {
-            "slot": 1,
-            "well": ["A1"],
-            "labware": "nest_12_reservoir_15ml",
-            "object": "source",
-        },
-        "plate_slot2": {
-            "slot": 2,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        },
-        "plate_slot3": {
-            "slot": 3,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        },
-        "plate_slot5": {
-            "slot": 5,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        },
-        "plate_slot6": {
-            "slot": 6,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        },
-        "tiprack_12": {
-            "slot": 12,
-            "well": [],
-            "labware": "opentrons_96_tiprack_300ul",
-            "object": "tiprack",
-        },
-    }
-
-
-def _cross_slot_protocol_steps(targets: List[str], dis_vols: List[float]) -> List[Dict[str, Any]]:
-    return [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "l1",
-                "targets": targets,
-                "tip_racks": "tiprack_12",
-                "asp_vols": dis_vols.copy(),
-                "dis_vols": dis_vols.copy(),
-            },
-            "step_number": 1,
-        }
-    ]
-
-
-# ==================== 用例 ====================
-
-
-def test_emit_merged_set_liquid_basic():
-    """51b9a5 主场景：targets=[A,B,C,D] → 1 merged set_liquid 节点
-    + 4 条入边（来自 4 个 distinct create_resource）+ 1 条出边（去 transfer_liquid）。
-    """
-    targets = ["plate_slot2", "plate_slot3", "plate_slot5", "plate_slot6"]
-    dis_vols = [8.3, 8.3, 8.3, 8.3]
-    g = build_protocol_graph(
-        labware_info=_cross_slot_labware_info(),
-        protocol_steps=_cross_slot_protocol_steps(targets, dis_vols),
-        workstation_name="PRCXI",
-    )
-
-    set_liquid_nodes = _nodes_by_template(g, "set_liquid_from_plate")
-    merged_nodes = [n for n in set_liquid_nodes if str(n.get("name", "")).startswith("_merged_targets_")]
-    assert len(merged_nodes) == 1, (
-        f"应有且仅有 1 个 merged set_liquid_from_plate 节点（v2 跨板聚合器）;"
-        f" 实际找到 {len(merged_nodes)}: {[n.get('name') for n in merged_nodes]}"
-    )
-    merged = merged_nodes[0]
-    merged_id = merged["id"]
-
-    # param.wells：长度 4，每元素的 parent 是对应 reagent_key
-    wells = merged.get("param", {}).get("wells") or []
-    assert len(wells) == 4
-    assert [w["parent"] for w in wells] == targets, "merged.wells 顺序必须严格按 targets 列表"
-    # well 字段映射到 reagent.well[0]（都是 "A1"）
-    for w, key in zip(wells, targets):
-        assert w["id"].endswith("/A1"), f"well id 应包含 well 名: {w}"
-        assert w["parent"] == key
-
-    # 入边：4 条来自 distinct create_resource 节点（slot 2/3/5/6），target_port=wells_identifier
-    cr_by_slot = _create_resource_by_slot(g)
-    in_edges = _edges_to(g, merged_id)
-    in_sources = {e["source"] for e in in_edges if e.get("target_handle_key") == "wells_identifier"}
-    expected_sources = {cr_by_slot[s] for s in ("2", "3", "5", "6")}
-    assert in_sources == expected_sources, (
-        f"merged 节点应接收 4 个 distinct create_resource 的 wells_identifier 边;"
-        f" 实际 {in_sources} vs 期望 {expected_sources}"
-    )
-
-    # 出边：1 条到 transfer_liquid（targets_identifier）
-    transfer_nodes = _nodes_by_template(g, "transfer_liquid")
-    assert len(transfer_nodes) == 1
-    transfer_id = transfer_nodes[0]["id"]
-    out_to_transfer = [
-        e for e in _edges_from(g, merged_id)
-        if e["target"] == transfer_id and e.get("target_handle_key") == "targets_identifier"
-    ]
-    assert len(out_to_transfer) == 1, (
-        f"merged 节点应向 transfer_liquid.targets_identifier 发出唯一 1 条边;"
-        f" 实际 {len(out_to_transfer)}"
-    )
-
-
-def test_emit_merged_set_liquid_repeat_key():
-    """同 reagent_key 重复（同板多孔）：targets=[A,A,A] + reagent.A.well=[A1,A2,A3]
-    → merged.wells 顺序 = [A/A1, A/A2, A/A3]（cursor 推进取每个 well）。
-    """
-    labware = _cross_slot_labware_info()
-    labware["plate_slot2"]["well"] = ["A1", "A2", "A3"]
-
-    targets = ["plate_slot2", "plate_slot2", "plate_slot2"]
-    dis_vols = [10.0, 20.0, 30.0]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=_cross_slot_protocol_steps(targets, dis_vols),
-        workstation_name="PRCXI",
-    )
-
-    merged_nodes = [
-        n for n in _nodes_by_template(g, "set_liquid_from_plate")
-        if str(n.get("name", "")).startswith("_merged_targets_")
-    ]
-    assert len(merged_nodes) == 1
-    wells = merged_nodes[0]["param"]["wells"]
-    assert [w["id"].rsplit("/", 1)[-1] for w in wells] == ["A1", "A2", "A3"], (
-        "cursor 应依次取 reagent.A.well[0/1/2]"
-    )
-    assert all(w["parent"] == "plate_slot2" for w in wells)
-
-
-def test_emit_merged_set_liquid_mixed():
-    """跨板 + 同板重复：targets=[A,B,A,C] + reagent.A.well=[A1,A2]
-    → merged.wells = [A/A1, B/A1, A/A2, C/A1]。
-    """
-    labware = _cross_slot_labware_info()
-    labware["plate_slot2"]["well"] = ["A1", "A2"]
-
-    targets = ["plate_slot2", "plate_slot3", "plate_slot2", "plate_slot5"]
-    dis_vols = [10.0, 20.0, 30.0, 40.0]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=_cross_slot_protocol_steps(targets, dis_vols),
-        workstation_name="PRCXI",
-    )
-
-    merged_nodes = [
-        n for n in _nodes_by_template(g, "set_liquid_from_plate")
-        if str(n.get("name", "")).startswith("_merged_targets_")
-    ]
-    assert len(merged_nodes) == 1
-    wells = merged_nodes[0]["param"]["wells"]
-    ids = [(w["parent"], w["id"].rsplit("/", 1)[-1]) for w in wells]
-    assert ids == [
-        ("plate_slot2", "A1"),
-        ("plate_slot3", "A1"),
-        ("plate_slot2", "A2"),
-        ("plate_slot5", "A1"),
-    ]
-
-
-def test_emit_merged_set_liquid_8ch():
-    """与 P1 multi-channel 复合：targets=[A]*8+[B]*8（每列 8 通道）。
-
-    merged.wells 长度 16，前 8 全 plate_slot2 的 8 个 well，后 8 全 plate_slot3 的 8 个 well。
-    """
-    labware = _cross_slot_labware_info()
-    # 8 通道场景 reagent.well 已被 P1 multi 展开为长度 8
-    labware["plate_slot2"]["well"] = [f"{r}1" for r in "ABCDEFGH"]
-    labware["plate_slot3"]["well"] = [f"{r}1" for r in "ABCDEFGH"]
-
-    targets = ["plate_slot2"] * 8 + ["plate_slot3"] * 8
-    dis_vols = [5.0] * 16
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=_cross_slot_protocol_steps(targets, dis_vols),
-        workstation_name="PRCXI",
-    )
-
-    merged_nodes = [
-        n for n in _nodes_by_template(g, "set_liquid_from_plate")
-        if str(n.get("name", "")).startswith("_merged_targets_")
-    ]
-    assert len(merged_nodes) == 1
-    wells = merged_nodes[0]["param"]["wells"]
-    assert len(wells) == 16
-    # 前 8 全 plate_slot2，后 8 全 plate_slot3（满足 cross-slot × 8ch 列对齐约束）
-    assert all(w["parent"] == "plate_slot2" for w in wells[:8])
-    assert all(w["parent"] == "plate_slot3" for w in wells[8:])
-    # well 名顺序：A1..H1 重复两遍
-    assert [w["id"].rsplit("/", 1)[-1] for w in wells[:8]] == [f"{r}1" for r in "ABCDEFGH"]
-    assert [w["id"].rsplit("/", 1)[-1] for w in wells[8:]] == [f"{r}1" for r in "ABCDEFGH"]
-
-
-def test_transfer_liquid_targets_rewrite():
-    """transfer_liquid 节点改写后只剩 1 条 targets_identifier 入边；params.targets 不再是 list。"""
-    targets = ["plate_slot2", "plate_slot3", "plate_slot5", "plate_slot6"]
-    dis_vols = [8.3, 8.3, 8.3, 8.3]
-    g = build_protocol_graph(
-        labware_info=_cross_slot_labware_info(),
-        protocol_steps=_cross_slot_protocol_steps(targets, dis_vols),
-        workstation_name="PRCXI",
-    )
-
-    transfer_nodes = _nodes_by_template(g, "transfer_liquid")
-    assert len(transfer_nodes) == 1
-    tnode = transfer_nodes[0]
-    transfer_id = tnode["id"]
-
-    # params.targets：v2 中 list 形态在 INPUT_PORT_MAPPING 处理后被清空（[]）或为单字符串
-    # （不再是原始 list[str]——避免下游 runtime 对其再做无序聚合）
-    tparams = tnode.get("param", {}) or {}
-    assert not isinstance(tparams.get("targets"), list) or tparams.get("targets") == [], (
-        f"v2：params.targets 不再是非空 list；实际 {tparams.get('targets')!r}"
-    )
-
-    # targets_identifier 端口：只有 1 条入边
-    in_targets_edges = [
-        e for e in _edges_to(g, transfer_id)
-        if e.get("target_handle_key") == "targets_identifier"
-    ]
-    assert len(in_targets_edges) == 1, (
-        f"v2：transfer_liquid.targets_identifier 必须是单入边（来自 merged set_liquid）;"
-        f" 实际 {len(in_targets_edges)}"
-    )
-
-    # 这条入边的源端口必须是 output_wells
-    edge = in_targets_edges[0]
-    assert edge.get("source_handle_key") == "output_wells"
-
-
-def test_str_targets_no_merged_node_emitted():
-    """对照组：targets 为 str（单 reagent） → 不插入 merged set_liquid_from_plate 节点。
-
-    保证 v2 改造**只**对 list 形态触发，单 reagent 走 P3 原有 per-plate set_liquid 路径。
-    """
-    labware = _cross_slot_labware_info()
-    labware["plate_slot2"]["well"] = ["A1", "A2", "A3"]
-
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "l1",
-                "targets": "plate_slot2",         # ← 单 str，非 list
-                "tip_racks": "tiprack_12",
-                "asp_vols": [8.3, 8.3, 8.3],
-                "dis_vols": [8.3, 8.3, 8.3],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-    merged_nodes = [
-        n for n in _nodes_by_template(g, "set_liquid_from_plate")
-        if str(n.get("name", "")).startswith("_merged_targets_")
-    ]
-    assert merged_nodes == [], "str 形态 targets 不应触发 v2 merged 聚合节点"

tests/workflow/test_common_liquid_name_from_reagent.py

@@ -1,452 +0,0 @@
-"""P8 — Stage 3 (``workflow/common.py``) 写入 ``set_liquid_from_plate.param.liquid_names`` 时
-优先取 ``reagent[key].liquid_name``，缺省时 fallback 到 reagent_key。
-
-对应 ``product_designs/protocol_convert/08-liquid-name-from-reagent-block.md`` §3.4 + §5。
-
-设计要点
---------
-- ``reagent[key].liquid_name`` 是 P8 新增的**可选**字段，承载真实化学名（与 reagent_key
-  解耦：reagent_key 仍是数据流引用名 / 业务别名，``liquid_name`` 是写入 PLR tracker /
-  前端的 human-readable 名称）。
-- ``liquid_name`` 来源优先级：Stage 0 mock ``Well.load_liquid(liquid=...)`` 实参 >
-  README 语义词 > 不写（Stage 3 fallback 到 reagent_key）。
-- ``liquid_name`` 保留空格 / 中文 / 括号等原字符，**不**做 snake_case / underscore 替换。
-- 旧 JSON（无 ``liquid_name`` 字段）行为完全不变（设计点 §7.A）。
-
-测试用例
---------
-- ``test_per_plate_fallback_when_no_liquid_name`` —— 缺省 fallback：
-  reagent 块无 ``liquid_name`` → liquid_names[i] == reagent_key（与 P8 前一致）。
-- ``test_per_plate_uses_explicit_liquid_name`` —— 显式 liquid_name：
-  liquid_names[i] == "EDTA Plasma"。
-- ``test_per_plate_preserves_spaces_and_special_chars`` —— 含空格 / 括号：
-  liquid_names[i] 不被 ``replace(" ", "_")`` 处理（不同于 reagent_key 用的 res_id）。
-- ``test_merged_node_uses_explicit_liquid_name_per_dispense`` —— merged 节点
-  每个 dispense 独立取 ``liquid_name or key``，部分有部分无能共存。
-- ``test_liquid_name_independent_of_reagent_key_normalization`` —— 与 P4 共存：
-  reagent_key 仍是 ``samples_2`` 等去重后缀，但 liquid_names 写的是真实化学名。
-"""
-from __future__ import annotations
-
-import sys
-import types
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-
-def _install_fake_optional_deps() -> None:
-    """与 test_common_set_liquid_dedup.py 一致的可选依赖 stub。"""
-    if "matplotlib" not in sys.modules:
-        sys.modules["matplotlib"] = types.ModuleType("matplotlib")
-    if "matplotlib.pyplot" not in sys.modules:
-        sys.modules["matplotlib.pyplot"] = types.ModuleType("matplotlib.pyplot")
-    try:
-        from networkx.drawing import nx_agraph  # noqa: F401
-    except Exception:
-        nx_drawing = types.ModuleType("networkx.drawing")
-        nx_agraph_mod = types.ModuleType("networkx.drawing.nx_agraph")
-        nx_agraph_mod.to_agraph = lambda _g: None  # type: ignore[attr-defined]
-        nx_drawing.nx_agraph = nx_agraph_mod  # type: ignore[attr-defined]
-        sys.modules["networkx.drawing"] = nx_drawing
-        sys.modules["networkx.drawing.nx_agraph"] = nx_agraph_mod
-
-
-_install_fake_optional_deps()
-
-import pytest  # noqa: E402
-
-from unilabos.workflow.common import build_protocol_graph  # noqa: E402
-
-
-# ==================== 辅助 ====================
-
-
-def _set_liquid_nodes(graph) -> List[Dict[str, Any]]:
-    return [
-        {"id": nid, **node}
-        for nid, node in graph.nodes.items()
-        if node.get("template_name") == "set_liquid_from_plate"
-    ]
-
-
-def _per_plate_for(graph, reagent_key: str) -> Dict[str, Any]:
-    """根据 ``description = "Set liquid: <reagent_key>"`` 反查 per-plate 节点。"""
-    for n in _set_liquid_nodes(graph):
-        if n.get("description") == f"Set liquid: {reagent_key}":
-            return n
-    raise AssertionError(f"未找到 per-plate set_liquid_from_plate(reagent_key={reagent_key!r})")
-
-
-def _merged_nodes(graph) -> List[Dict[str, Any]]:
-    return [
-        n for n in _set_liquid_nodes(graph)
-        if str(n.get("name", "")).startswith("_merged_targets_")
-    ]
-
-
-def _make_source_target_labware(
-    *,
-    source_key: str = "src_1",
-    source_liquid_name: str | None = None,
-    target_keys: List[str] | None = None,
-    target_liquid_names: Dict[str, str] | None = None,
-) -> Dict[str, Dict[str, Any]]:
-    """构造 1 个 source + N 个 target reagent + 1 个 tip rack。
-
-    ``*_liquid_name`` 为 None / 缺省时**不**写入 ``liquid_name`` 字段，
-    模拟旧 schema / mock 未给 liquid_name 的真实回归场景。
-    """
-    info: Dict[str, Dict[str, Any]] = {}
-    source_entry: Dict[str, Any] = {
-        "slot": 1,
-        "well": ["A1"],
-        "labware": "nest_12_reservoir_15ml",
-        "object": "source",
-    }
-    if source_liquid_name is not None:
-        source_entry["liquid_name"] = source_liquid_name
-    info[source_key] = source_entry
-
-    target_keys = target_keys or ["t_A"]
-    target_liquid_names = target_liquid_names or {}
-    for i, tk in enumerate(target_keys, start=1):
-        entry: Dict[str, Any] = {
-            "slot": 2 + i,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        }
-        if tk in target_liquid_names:
-            entry["liquid_name"] = target_liquid_names[tk]
-        info[tk] = entry
-
-    info["tiprack_12"] = {
-        "slot": 12,
-        "well": [],
-        "labware": "opentrons_96_tiprack_300ul",
-        "object": "tiprack",
-    }
-    return info
-
-
-# ==================== T1 缺省 fallback ====================
-
-
-def test_per_plate_fallback_when_no_liquid_name():
-    """reagent block 无 ``liquid_name`` 字段 → liquid_names[i] == reagent_key（P8 前行为）。"""
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        target_keys=["t_A"],
-        # 都不给 liquid_name
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    src_node = _per_plate_for(g, "src_1")
-    tgt_node = _per_plate_for(g, "t_A")
-    assert src_node["param"]["liquid_names"] == ["src_1"], (
-        f"无 liquid_name 时 source per-plate 应 fallback 到 reagent_key；"
-        f" 实际 {src_node['param']['liquid_names']}"
-    )
-    assert tgt_node["param"]["liquid_names"] == ["t_A"], (
-        f"无 liquid_name 时 target per-plate 应 fallback 到 reagent_key；"
-        f" 实际 {tgt_node['param']['liquid_names']}"
-    )
-
-
-# ==================== T2 显式 liquid_name ====================
-
-
-def test_per_plate_uses_explicit_liquid_name():
-    """reagent block 含 ``liquid_name`` → liquid_names[i] 用该值（不是 reagent_key）。"""
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        source_liquid_name="EDTA Plasma",
-        target_keys=["t_A"],
-        target_liquid_names={"t_A": "PBS Diluent"},
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    src_node = _per_plate_for(g, "src_1")
-    tgt_node = _per_plate_for(g, "t_A")
-    assert src_node["param"]["liquid_names"] == ["EDTA Plasma"], (
-        f"source per-plate 应使用 reagent.liquid_name；实际 {src_node['param']['liquid_names']}"
-    )
-    assert tgt_node["param"]["liquid_names"] == ["PBS Diluent"], (
-        f"target per-plate 应使用 reagent.liquid_name；实际 {tgt_node['param']['liquid_names']}"
-    )
-
-
-# ==================== T3 空格 / 括号 ====================
-
-
-def test_per_plate_preserves_spaces_and_special_chars():
-    """``liquid_name`` 保留空格 / 括号 / 中文等原字符，不被 replace(' ', '_') 处理。
-
-    这条与 reagent_key 走 ``res_id = str(labware_id).replace(' ', '_')`` 的语义不同。
-    """
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        source_liquid_name="Tris HCl pH 8.0 (1×)",
-        target_keys=["t_A"],
-        target_liquid_names={"t_A": "稀释液 A"},
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    src_node = _per_plate_for(g, "src_1")
-    tgt_node = _per_plate_for(g, "t_A")
-
-    assert src_node["param"]["liquid_names"] == ["Tris HCl pH 8.0 (1×)"], (
-        f"空格 / 括号应原样保留；实际 {src_node['param']['liquid_names']}"
-    )
-    assert tgt_node["param"]["liquid_names"] == ["稀释液 A"], (
-        f"中文应原样保留；实际 {tgt_node['param']['liquid_names']}"
-    )
-
-    # reagent_key 自身仍受 ``res_id = replace(' ', '_')`` 影响，
-    # 但本测试 reagent_key 不含空格，故 sl_node_title 仍以 reagent_key 为根。
-    # 这里仅断言 liquid_names 字段独立于 reagent_key normalize。
-
-
-# ==================== T4 merged 节点跨板部分有部分无 ====================
-
-
-def test_merged_node_uses_explicit_liquid_name_per_dispense():
-    """merged 节点 ``liquid_names`` 与 list-targets 同长，每个元素独立取
-    ``reagent[key].liquid_name or key``：本例 3 个 target，2 个有显式名、1 个无。
-    """
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        target_keys=["t_A", "t_B", "t_C"],
-        target_liquid_names={
-            "t_A": "Plasma",
-            # t_B 无 liquid_name
-            "t_C": "Buffer X",
-        },
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": ["t_A", "t_B", "t_C"],
-                "tip_racks": "tiprack_12",
-                "asp_vols": [5.0] * 3,
-                "dis_vols": [5.0] * 3,
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    merged = _merged_nodes(g)
-    assert len(merged) == 1, f"应有 1 个 merged 节点，实际 {len(merged)}"
-    liquid_names = merged[0]["param"]["liquid_names"]
-    assert liquid_names == ["Plasma", "t_B", "Buffer X"], (
-        f"merged 每 dispense 独立取 liquid_name or key；实际 {liquid_names}"
-    )
-
-
-# ==================== T5 与 P4 reagent_key 后缀共存 ====================
-
-
-def test_liquid_name_independent_of_reagent_key_normalization():
-    """P4 命名链产生 ``samples_2`` 这种带后缀的 reagent_key（跨板去重）；
-    P8 ``liquid_name`` 应保持原始化学名，**不**带 P4 的去重后缀。
-
-    构造：2 个 target reagent_keys ``samples`` / ``samples_2``（不同 slot，
-    模拟跨板同液体被 Stage 2 去重），都标 liquid_name="Bacterial Culture"。
-    """
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        target_keys=["samples", "samples_2"],
-        target_liquid_names={
-            "samples": "Bacterial Culture",
-            "samples_2": "Bacterial Culture",
-        },
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": ["samples", "samples_2"],
-                "tip_racks": "tiprack_12",
-                "asp_vols": [5.0, 5.0],
-                "dis_vols": [5.0, 5.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    merged = _merged_nodes(g)
-    assert len(merged) == 1
-    liquid_names = merged[0]["param"]["liquid_names"]
-    assert liquid_names == ["Bacterial Culture", "Bacterial Culture"], (
-        f"P8 liquid_name 应与 P4 reagent_key 后缀解耦：同液体的两个 reagent_key 应得相同"
-        f" liquid_name；实际 {liquid_names}"
-    )
-    # 同时 reagent_key 仍是 samples / samples_2（不变）
-    wells = merged[0]["param"]["wells"]
-    parents = [w["parent"] for w in wells]
-    assert parents == ["samples", "samples_2"], (
-        f"merged wells.parent 应等于 list-targets reagent_keys；实际 {parents}"
-    )
-
-
-# ==================== T6 source per-plate / target per-plate 同步生效 ====================
-
-
-def test_both_source_and_target_per_plate_use_liquid_name():
-    """str-targets 路径（无 merged）下，source 和 target 都走 per-plate emit，
-    各自独立取 ``liquid_name``。"""
-    labware = _make_source_target_labware(
-        source_key="src_1",
-        source_liquid_name="Reagent A",
-        target_keys=["t_A"],
-        target_liquid_names={"t_A": "Reagent B"},
-    )
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",  # str-targets，不触发 merged
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    assert _merged_nodes(g) == [], "str-targets 不应产生 merged 节点"
-    src_node = _per_plate_for(g, "src_1")
-    tgt_node = _per_plate_for(g, "t_A")
-    assert src_node["param"]["liquid_names"] == ["Reagent A"]
-    assert tgt_node["param"]["liquid_names"] == ["Reagent B"]
-
-
-# ==================== T7 多孔同 reagent → 整列 liquid_names 一致 ====================
-
-
-def test_multi_well_reagent_replicates_liquid_name():
-    """1 个 reagent 含 8 wells（multi-channel 扩展场景）→ liquid_names 应是
-    ``[liquid_name] * 8``，与 wells 长度一致。"""
-    labware: Dict[str, Dict[str, Any]] = {
-        "src_1": {
-            "slot": 1,
-            "well": ["A1", "B1", "C1", "D1", "E1", "F1", "G1", "H1"],
-            "labware": "nest_96_wellplate_100ul_pcr_full_skirt",
-            "object": "source",
-            "liquid_name": "Mastermix",
-        },
-        "t_A": {
-            "slot": 3,
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        },
-        "tiprack_12": {
-            "slot": 12,
-            "well": [],
-            "labware": "opentrons_96_tiprack_300ul",
-            "object": "tiprack",
-        },
-    }
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    src_node = _per_plate_for(g, "src_1")
-    liquid_names = src_node["param"]["liquid_names"]
-    assert liquid_names == ["Mastermix"] * 8, (
-        f"per-plate 应把 liquid_name 复制 well_count 份；实际 {liquid_names}"
-    )
-    # 同时 wells / volumes 长度一致
-    assert len(src_node["param"]["wells"]) == 8
-    assert len(src_node["param"]["volumes"]) == 8

tests/workflow/test_common_plate_num_children_hint.py

@@ -1,174 +0,0 @@
-"""P6 §17 hint bug —— `_infer_plate_num_children_from_labware_hint` 误把
-reagent_id 末尾数字（如 ``samples_6`` 的 ``_6``）当作孔板规格，导致
-``_apply_target_labware_class_auto_match`` fallback 到 PRCXI 4-孔 trough 模板。
-
-跨板 fix（P2 v2 §14）把 plate name 作为 prefix 编码进 ``well_names`` 之后，
-runtime 调用 ``plate.get_well("A5")`` 严格定位 well，trough plate 上不存在
-``A5`` 会直接 IndexError，使得这个隐藏多年的孔数推断 bug 浮出。
-
-修复策略（方案 A）
------
-hint 只用 ``item.get("labware", "")``，**不再**拼上 ``labware_id``（reagent_key
-是业务名，不应参与孔板规格推断）。
-
-测试矩阵
-----
-- ``test_reagent_key_numeric_suffix_must_not_match_hint`` —— samples_6 / samples_24 /
-  samples_96 + nunc_rectangular_agar_plate → hint 返回 None（labware string 不带孔数信息）。
-- ``test_labware_string_X_well_correctly_inferred`` —— labware="nest_96_wellplate..." → 96；
-  "custom_384_wellplate" → 384；"nest_24_wellplate_2ml_pcr" → 24。
-- ``test_apply_does_not_classify_samples_6_as_trough`` —— 集成：构造 Agar Plating-like
-  reagent block（slot 8 上 12 个 samples_X，X 末尾含 6/24/96），跑
-  ``_apply_target_labware_class_auto_match`` 后，samples_6/24 不再得到 trough class。
-- ``test_real_labware_96_wellplate_still_inferred_via_labware_str`` —— 即便 labware_id
-  与孔数无关，``nest_96_wellplate_100ul_pcr_full_skirt`` 这种 labware 命名仍应被识别为 96。
-"""
-from __future__ import annotations
-
-import sys
-import types
-from pathlib import Path
-
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-
-def _install_fake_optional_deps() -> None:
-    if "matplotlib" not in sys.modules:
-        sys.modules["matplotlib"] = types.ModuleType("matplotlib")
-    if "matplotlib.pyplot" not in sys.modules:
-        sys.modules["matplotlib.pyplot"] = types.ModuleType("matplotlib.pyplot")
-
-
-_install_fake_optional_deps()
-
-import pytest  # noqa: E402
-
-from unilabos.workflow.common import (  # noqa: E402
-    _apply_target_labware_class_auto_match,
-    _infer_plate_num_children_from_labware_hint,
-    _reconcile_slot_carrier_target_class,
-)
-
-
-# ==================== unit：hint 函数本身 ====================
-
-
-@pytest.mark.parametrize(
-    "labware_id",
-    ["samples_6", "samples_24", "samples_96", "samples_12", "samples_48"],
-)
-def test_reagent_key_numeric_suffix_must_not_match_hint(labware_id):
-    """reagent_id 末尾的孔数关键字数字不应被识别为孔板规格。"""
-    item = {
-        "slot": 8,
-        "well": ["A5"],
-        "labware": "nunc_rectangular_agar_plate",
-        "object": "target",
-    }
-    assert _infer_plate_num_children_from_labware_hint(labware_id, item) is None, (
-        f"reagent_id {labware_id!r} 不应被识别为孔板规格 "
-        f"（其末尾数字应当被忽略；labware string 不含 96/384/etc 关键字）"
-    )
-
-
-@pytest.mark.parametrize(
-    "labware_str,expected",
-    [
-        ("nest_96_wellplate_100ul_pcr_full_skirt", 96),
-        ("custom_384_wellplate", 384),
-        ("nest_24_wellplate_2ml_pcr", 24),
-        ("custom_48_wellplate", 48),
-        ("opentrons_12_wellplate_15ml", 12),
-        ("nest_6_wellplate_5ml", 6),
-        ("nunc_rectangular_agar_plate", None),
-        ("", None),
-    ],
-)
-def test_labware_string_well_count_inferred(labware_str, expected):
-    item = {"labware": labware_str}
-    assert (
-        _infer_plate_num_children_from_labware_hint("samples", item) == expected
-    ), f"labware {labware_str!r} 应推断为 {expected!r}"
-
-
-# ==================== integration：模拟 Agar Plating ====================
-
-
-def _agar_plating_reagent_block():
-    """反推自 unilabos_data/req_workflow_upload.json：12 列 × 9 reagent per step。
-
-    slot 8 (mapped 14) 上 12 个 reagent_keys: samples_6, samples_15, samples_24,
-    samples_33, samples_42, samples_51, samples_60, samples_69, samples_78,
-    samples_87, samples_96, samples_105.
-    """
-    info = {}
-    slot_for_idx = {0: 3, 1: 4, 2: 5, 3: 6, 4: 7, 5: 8, 6: 9, 7: 10, 8: 11}
-    cols = [f"A{i + 1}" for i in range(12)]
-    for col_i, col in enumerate(cols):
-        for di in range(9):
-            n = col_i * 9 + di + 1
-            key = "samples" if n == 1 else f"samples_{n}"
-            info[key] = {
-                "slot": slot_for_idx[di],
-                "well": [col],
-                "labware": "nunc_rectangular_agar_plate",
-                "object": "target",
-            }
-    for i in range(12):
-        key = "sources" if i == 0 else f"sources_{i + 1}"
-        info[key] = {
-            "slot": 2,
-            "well": [cols[i]],
-            "labware": "nest_96_wellplate_100ul_pcr_full_skirt",
-            "object": "source",
-        }
-    info["tiprack_1"] = {
-        "slot": 1,
-        "well": None,
-        "labware": "opentrons_96_tiprack_10ul",
-        "object": "tiprack",
-    }
-    info["trash"] = {
-        "slot": 12,
-        "well": None,
-        "labware": "opentrons_1_trash_1100ml_fixed",
-        "object": "trash",
-    }
-    return info
-
-
-def test_apply_does_not_classify_samples_6_as_trough():
-    """集成回归：Agar Plating-like reagent block 跑完类匹配 + slot 统一后，
-    slot 8 上 12 个 reagent 不应得到 4-孔 trough class。"""
-    info = _agar_plating_reagent_block()
-    _apply_target_labware_class_auto_match(
-        info, preserve_tip_rack_incoming_class=True, target_device="prcxi"
-    )
-    _reconcile_slot_carrier_target_class(
-        info, preserve_tip_rack_incoming_class=True, target_device="prcxi"
-    )
-    slot8_keys = [
-        "samples_6", "samples_15", "samples_24", "samples_33",
-        "samples_42", "samples_51", "samples_60", "samples_69",
-        "samples_78", "samples_87", "samples_96", "samples_105",
-    ]
-    for k in slot8_keys:
-        cls = info[k].get("target_class_name") or ""
-        assert "trough" not in cls.lower(), (
-            f"reagent {k} 被误识别为 trough class: {cls!r}；"
-            "这通常是 hint 误把 reagent_id 末尾数字当孔板规格"
-        )
-
-
-def test_real_labware_96_wellplate_still_inferred_via_labware_str():
-    """labware string 含 96_wellplate 时应该正常识别为 96，不被 fix 破坏。"""
-    item = {
-        "slot": 2,
-        "well": ["A1"],
-        "labware": "nest_96_wellplate_100ul_pcr_full_skirt",
-        "object": "source",
-    }
-    assert _infer_plate_num_children_from_labware_hint("sources", item) == 96

tests/workflow/test_common_set_liquid_dedup.py

@@ -1,379 +0,0 @@
-"""P2 v2 §14 set_liquid_from_plate 去重 —— Stage 3 (`workflow/common.py`) 集成测试。
-
-对应 ``product_designs/protocol_convert/02-cross-slot-merge.md`` §14（2026-05-22 plan）。
-
-§14 设计要点
------------------
-当 ``transfer_liquid.params.targets`` 是 ``list[str]`` 时，``_emit_merged_set_liquid``
-已经为该 transfer 插入一个 merged ``set_liquid_from_plate`` 节点，
-其 ``param.wells`` 聚合了 list 中所有 reagent_keys 的跨板 wells。
-
-§14 之前：第二步循环（``for labware_id, item in labware_info.items()``）仍然为
-list-targets 中出现的每个 reagent_key 创建一个 per-plate ``set_liquid_from_plate`` 节点，
-导致**节点冗余**（per-plate 节点的 ``output_wells`` 对 transfer_liquid 的
-``targets_identifier`` 边毫无贡献 —— transfer_liquid 单边只接 merged 节点）。
-
-§14 改造：在第二步循环**之前**预扫描 protocol_steps，收集
-``set_liquid_covered_by_merged: Set[str]``（出现在某个 list[str] targets 中的所有 keys）
-与 ``set_liquid_referenced_by_str: Set[str]``（出现在 str targets 中的所有 keys）。
-循环内对 ``object="target"`` 且 ``key ∈ covered ∧ key ∉ referenced_by_str`` 的 reagent_key
-**跳过** per-plate 节点创建。
-
-测试用例
-----
-- ``test_per_plate_skipped_when_covered_by_merged`` —— list-targets 覆盖的
-  target reagent_keys 不再产生 per-plate set_liquid_from_plate。
-- ``test_per_plate_kept_when_also_referenced_by_str_targets`` —— R1 缓解：
-  同时被 list-targets 和 str-targets 引用的 reagent_key 仍保留 per-plate。
-- ``test_str_targets_protocol_unaffected`` —— 单 slot 协议（仅 str-targets）
-  节点数完全不变（回归防护）。
-- ``test_51b9a5_style_node_count`` —— 12 list-targets × len=9 大规模场景：
-  set_liquid_from_plate 总节点数 = source per-plate + merged + 0 target per-plate。
-- ``test_source_per_plate_always_kept`` —— source 端不受 §14 影响：source
-  reagent_keys 不出现在 targets 字段中，per-plate 节点恒在。
-"""
-from __future__ import annotations
-
-import sys
-import types
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-
-def _install_fake_optional_deps() -> None:
-    """与 test_common_cross_slot_v2.py 一致的可选依赖 stub。"""
-    if "matplotlib" not in sys.modules:
-        sys.modules["matplotlib"] = types.ModuleType("matplotlib")
-    if "matplotlib.pyplot" not in sys.modules:
-        sys.modules["matplotlib.pyplot"] = types.ModuleType("matplotlib.pyplot")
-    try:
-        from networkx.drawing import nx_agraph  # noqa: F401
-    except Exception:
-        nx_drawing = types.ModuleType("networkx.drawing")
-        nx_agraph_mod = types.ModuleType("networkx.drawing.nx_agraph")
-        nx_agraph_mod.to_agraph = lambda _g: None  # type: ignore[attr-defined]
-        nx_drawing.nx_agraph = nx_agraph_mod  # type: ignore[attr-defined]
-        sys.modules["networkx.drawing"] = nx_drawing
-        sys.modules["networkx.drawing.nx_agraph"] = nx_agraph_mod
-
-
-_install_fake_optional_deps()
-
-import pytest  # noqa: E402
-
-from unilabos.workflow.common import build_protocol_graph  # noqa: E402
-
-
-# ==================== 辅助 ====================
-
-
-def _nodes_by_template(graph, template_name: str) -> List[Dict[str, Any]]:
-    return [
-        {"id": nid, **node}
-        for nid, node in graph.nodes.items()
-        if node.get("template_name") == template_name
-    ]
-
-
-def _set_liquid_nodes_split(graph):
-    """返回 (per_plate_nodes, merged_nodes)。merged 节点 name 以 `_merged_targets_` 开头。"""
-    all_sl = _nodes_by_template(graph, "set_liquid_from_plate")
-    merged = [n for n in all_sl if str(n.get("name", "")).startswith("_merged_targets_")]
-    per_plate = [n for n in all_sl if not str(n.get("name", "")).startswith("_merged_targets_")]
-    return per_plate, merged
-
-
-def _labware_with_targets(target_keys: List[str], source_keys: List[str] | None = None) -> Dict[str, Dict[str, Any]]:
-    """构造 labware_info：source 端 1 个 + 任意数量 target plates + tip rack。"""
-    info: Dict[str, Dict[str, Any]] = {}
-    source_keys = source_keys or ["src_1"]
-    for i, sk in enumerate(source_keys, start=1):
-        info[sk] = {
-            "slot": 1 + i - 1,  # slot 1 占位（实际可能映射）
-            "well": ["A1"],
-            "labware": "nest_12_reservoir_15ml",
-            "object": "source",
-        }
-    for i, tk in enumerate(target_keys, start=1):
-        info[tk] = {
-            "slot": 2 + i,  # 错开 source 使用的 slot
-            "well": ["A1"],
-            "labware": "nest_96_wellplate_2ml_deep",
-            "object": "target",
-        }
-    info["tiprack_12"] = {
-        "slot": 12,
-        "well": [],
-        "labware": "opentrons_96_tiprack_300ul",
-        "object": "tiprack",
-    }
-    return info
-
-
-# ==================== 用例 ====================
-
-
-def test_per_plate_skipped_when_covered_by_merged():
-    """单 list-targets transfer 覆盖 4 个 target reagent_keys → per-plate 不再出现。"""
-    targets = ["t_A", "t_B", "t_C", "t_D"]
-    labware = _labware_with_targets(targets, source_keys=["src_1"])
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": targets,
-                "tip_racks": "tiprack_12",
-                "asp_vols": [8.0] * 4,
-                "dis_vols": [8.0] * 4,
-            },
-            "step_number": 1,
-        }
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    per_plate, merged = _set_liquid_nodes_split(g)
-
-    # merged 节点：1 个
-    assert len(merged) == 1, f"应有 1 个 merged 节点；实际 {len(merged)}"
-
-    # per-plate 节点：仅 source 1 个（src_1）；target 端被全部跳过
-    per_plate_names = {n.get("description", "") for n in per_plate}
-    per_plate_keys = {
-        n.get("description", "").replace("Set liquid: ", "")
-        for n in per_plate
-    }
-    assert "src_1" in per_plate_keys, "source 端 per-plate 必须保留"
-    for tk in targets:
-        assert tk not in per_plate_keys, (
-            f"§14：target reagent_key '{tk}' 已被 merged 覆盖，不应再有 per-plate 节点；"
-            f" 实际 per_plate_keys={per_plate_keys}"
-        )
-
-
-def test_per_plate_kept_when_also_referenced_by_str_targets():
-    """R1 缓解：t_A 既被 list-targets 引用，又被 str-targets 引用 → per-plate 必须保留。"""
-    targets_list = ["t_A", "t_B", "t_C"]
-    labware = _labware_with_targets(targets_list, source_keys=["src_1"])
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": targets_list,
-                "tip_racks": "tiprack_12",
-                "asp_vols": [5.0] * 3,
-                "dis_vols": [5.0] * 3,
-            },
-            "step_number": 1,
-        },
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 2,
-        },
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    per_plate, merged = _set_liquid_nodes_split(g)
-    per_plate_keys = {
-        n.get("description", "").replace("Set liquid: ", "")
-        for n in per_plate
-    }
-
-    assert "t_A" in per_plate_keys, (
-        f"R1：t_A 被 str transfer #2 引用，必须保留 per-plate 节点；"
-        f" 实际 per_plate_keys={per_plate_keys}"
-    )
-    assert "t_B" not in per_plate_keys, "t_B 仅出现在 list-targets，应跳过"
-    assert "t_C" not in per_plate_keys, "t_C 仅出现在 list-targets，应跳过"
-
-    # merged 节点数：1（仅 list-targets transfer #1 生成）
-    assert len(merged) == 1
-
-
-def test_str_targets_protocol_unaffected():
-    """单 slot 协议（全 str-targets）→ 每个 target reagent_key 仍有 per-plate（零回归）。"""
-    labware = _labware_with_targets(["t_A", "t_B"], source_keys=["src_1"])
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 1,
-        },
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_1",
-                "targets": "t_B",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [20.0],
-                "dis_vols": [20.0],
-            },
-            "step_number": 2,
-        },
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    per_plate, merged = _set_liquid_nodes_split(g)
-    per_plate_keys = {
-        n.get("description", "").replace("Set liquid: ", "")
-        for n in per_plate
-    }
-
-    assert merged == [], "全 str-targets 协议不应触发 merged 节点"
-    assert {"src_1", "t_A", "t_B"}.issubset(per_plate_keys), (
-        f"单 slot 协议每个 reagent_key（含 source/target）都应保留 per-plate；"
-        f" 实际 {per_plate_keys}"
-    )
-
-
-def test_51b9a5_style_node_count():
-    """大规模场景：N 个 list-targets transfers，每个长度 M（同 source 不同跨板）。
-
-    构造：2 个 source（src_A1、src_A2）+ 9 个 target plates × 2 个 well = 18 target reagent_keys。
-    2 个 transfer：
-      - transfer #1: targets = [t_A1_1, t_A1_2, ..., t_A1_9]（同 source src_A1，跨 9 plate）
-      - transfer #2: targets = [t_A2_1, t_A2_2, ..., t_A2_9]（同 source src_A2，跨 9 plate）
-
-    期望 set_liquid_from_plate 总节点数 = 2 source per-plate + 2 merged + 0 target per-plate = 4。
-    """
-    target_keys_a1 = [f"t_A1_{i}" for i in range(1, 10)]
-    target_keys_a2 = [f"t_A2_{i}" for i in range(1, 10)]
-    all_target_keys = target_keys_a1 + target_keys_a2
-
-    labware = _labware_with_targets(
-        all_target_keys,
-        source_keys=["src_A1", "src_A2"],
-    )
-
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_A1",
-                "targets": target_keys_a1,
-                "tip_racks": "tiprack_12",
-                "asp_vols": [8.3] * 9,
-                "dis_vols": [8.3] * 9,
-            },
-            "step_number": 1,
-        },
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_A2",
-                "targets": target_keys_a2,
-                "tip_racks": "tiprack_12",
-                "asp_vols": [8.3] * 9,
-                "dis_vols": [8.3] * 9,
-            },
-            "step_number": 2,
-        },
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    per_plate, merged = _set_liquid_nodes_split(g)
-
-    assert len(merged) == 2, f"应有 2 个 merged 节点；实际 {len(merged)}"
-
-    per_plate_keys = {
-        n.get("description", "").replace("Set liquid: ", "")
-        for n in per_plate
-    }
-
-    # source 端：2 个 per-plate
-    assert "src_A1" in per_plate_keys and "src_A2" in per_plate_keys, (
-        f"source 端必须有 src_A1 + src_A2 per-plate；实际 {per_plate_keys}"
-    )
-
-    # target 端：18 个全部被跳过
-    for tk in all_target_keys:
-        assert tk not in per_plate_keys, (
-            f"§14：target reagent_key '{tk}' 应被 merged 覆盖并跳过；"
-            f" 实际 per_plate_keys 包含 {tk}"
-        )
-
-    # 总节点数 == 2 + 2
-    assert len(per_plate) + len(merged) == 4, (
-        f"set_liquid_from_plate 总节点数应为 4 (2 source + 2 merged + 0 target per-plate);"
-        f" 实际 per_plate={len(per_plate)} merged={len(merged)}"
-    )
-
-
-def test_source_per_plate_always_kept():
-    """source reagent_keys 不出现在任何 targets 字段中 → per-plate 节点恒保留（与 §14 无关）。"""
-    target_keys = ["t_A", "t_B", "t_C"]
-    labware = _labware_with_targets(target_keys, source_keys=["src_X", "src_Y"])
-
-    steps = [
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_X",
-                "targets": target_keys,
-                "tip_racks": "tiprack_12",
-                "asp_vols": [5.0] * 3,
-                "dis_vols": [5.0] * 3,
-            },
-            "step_number": 1,
-        },
-        {
-            "action": "transfer_liquid",
-            "parameters": {
-                "sources": "src_Y",
-                "targets": "t_A",
-                "tip_racks": "tiprack_12",
-                "asp_vols": [10.0],
-                "dis_vols": [10.0],
-            },
-            "step_number": 2,
-        },
-    ]
-    g = build_protocol_graph(
-        labware_info=labware,
-        protocol_steps=steps,
-        workstation_name="PRCXI",
-    )
-
-    per_plate, _ = _set_liquid_nodes_split(g)
-    per_plate_keys = {
-        n.get("description", "").replace("Set liquid: ", "")
-        for n in per_plate
-    }
-
-    assert "src_X" in per_plate_keys, "source src_X 必须有 per-plate（source 不会被 §14 跳过）"
-    assert "src_Y" in per_plate_keys, "source src_Y 必须有 per-plate"

tests/workflow/test_labware_mapping.py

@@ -1,534 +0,0 @@
-"""P6 / P6.1 / P6.1.1 `labware_mapping.py` 单元测试 —— 对应 06-labware-mapping-table.md §11.7.7 / §11.8.7。
-
-这些用例只依赖 `unilabos.workflow.labware_mapping` 自身与 PyYAML，
-不需要 ROS2 / matplotlib / networkx 等环境，可直接 `pytest tests/workflow/test_labware_mapping.py`。
-
-P6.1.1 schema（v1.9）：
-- 顶层 key 两段：``kinds`` / ``target_devices``（**P6.1.1 起顶层 `slot_remap` 已不支持**，下沉到 ``target_devices.<device>`` 内）
-- ``target_devices.default`` 是固定段名，作为兜底物料集，第一版按 prcxi 拷贝填充，**不支持 `models` 子段**
-- ``target_devices.<device>.models.<model>`` 是可选的型号粒度覆盖（slot_remap / rules）
-- 旧 schema（顶层 ``vendors`` / ``slot_remap`` 或 rule 含 ``prcxi_class``）会触发 warning + fallback 到 builtin
-"""
-from __future__ import annotations
-
-import sys
-import warnings
-from pathlib import Path
-
-import pytest
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-from unilabos.workflow import labware_mapping as lm
-
-
-@pytest.fixture(autouse=True)
-def _reset_lru_cache():
-    """每个用例后清缓存，避免 monkeypatch 跨用例污染。"""
-    yield
-    lm.reload_mapping()
-
-
-# ==================== slot_remap ====================
-
-
-@pytest.mark.parametrize(
-    "raw,object_type,want",
-    [
-        ("4", "", "13"),
-        ("8", "", "14"),
-        ("12", "trash", "16"),
-        ("12", "source", "12"),
-        ("1", "", "1"),
-        ("", "", ""),
-        (4, "", "13"),  # 非字符串入参也应规整
-    ],
-)
-def test_remap_slot_basic(raw, object_type, want):
-    assert lm.remap_slot(raw, object_type) == want
-
-
-def test_remap_slot_none_returns_empty():
-    assert lm.remap_slot(None) == ""
-
-
-def test_remap_slot_passthrough_unknown():
-    assert lm.remap_slot("99") == "99"
-
-
-# ==================== infer_kind ====================
-
-
-def test_infer_kind_trash_priority():
-    """`trash` 在 kinds 列表第 1 条 → 优先于含 'rack' 的字符串。"""
-    assert lm.infer_kind("foo_trash_bar") == "trash"
-    assert lm.infer_kind("opentrons_fixed_trash") == "trash"
-
-
-def test_infer_kind_tiprack_before_tuberack():
-    """`tiprack` 子串包含 'rack'，但应被 tip_rack 规则先抓到（顺序敏感）。"""
-    assert lm.infer_kind("opentrons_96_tiprack_300ul") == "tip_rack"
-    assert lm.infer_kind("opentrons_96_tiprack_20ul") == "tip_rack"
-
-
-def test_infer_kind_tube_rack_variants():
-    assert (
-        lm.infer_kind("opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap")
-        == "tube_rack"
-    )
-    assert lm.infer_kind("opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical") == "tube_rack"
-
-
-def test_infer_kind_object_overrides_string():
-    """object 字段优先：即使字符串看起来像 plate，trash / tiprack 也能强制归类。"""
-    assert lm.infer_kind("anything_at_all", "tiprack") == "tip_rack"
-    assert lm.infer_kind("opentrons_96_wellplate", "trash") == "trash"
-
-
-def test_infer_kind_default_plate():
-    assert lm.infer_kind("opentrons_96_wellplate_300ul_pcr") == "plate"
-    assert lm.infer_kind("custom_384_wellplate_2200ul") == "plate"
-
-
-def test_infer_kind_rack_without_tip_is_tube_rack():
-    """复现历史 `_infer_reagent_kind` 中「含 rack 不含 tip → tube_rack」的语义。"""
-    assert lm.infer_kind("nest_4x6_rack") == "tube_rack"
-
-
-def test_infer_kind_empty_hint_returns_plate():
-    assert lm.infer_kind("") == "plate"
-    assert lm.infer_kind(None) == "plate"  # type: ignore[arg-type]
-
-
-# ==================== resolve_target_class（target_device="prcxi"） ====================
-
-
-@pytest.mark.parametrize(
-    "vol,want",
-    [
-        (1, "PRCXI_10uL_Tips"),
-        (9, "PRCXI_10uL_Tips"),
-        (10, "PRCXI_10uL_Tips"),  # 闭区间 ≤10
-        (11, "PRCXI_300ul_Tips"),
-        (200, "PRCXI_300ul_Tips"),
-        (299.9, "PRCXI_300ul_Tips"),
-        (300, "PRCXI_1000uL_Tips"),  # 300 上一档（与 <300 半开等价）
-        (500, "PRCXI_1000uL_Tips"),
-        (1000, "PRCXI_1000uL_Tips"),
-    ],
-)
-def test_resolve_tip_volume_buckets(vol, want):
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, vol) == want
-
-
-def test_resolve_tube_rack_holes():
-    assert lm.resolve_target_class("prcxi", "tube_rack", 24, None) == "PRCXI_EP_Adapter"
-    assert lm.resolve_target_class("prcxi", "tube_rack", 10, None) == "PRCXI_EP_Adapter"
-
-
-def test_resolve_plate_holes():
-    assert lm.resolve_target_class("prcxi", "plate", 96, None) == "PRCXI_BioER_96_wellplate"
-    assert (
-        lm.resolve_target_class("prcxi", "plate", 384, None) == "PRCXI_BioER_384_wellplate"
-    )
-
-
-def test_resolve_plate_unknown_holes_returns_none():
-    """48 孔板未在 YAML 列出 → None；交给 PRCXI 模板打分匹配 fallback。"""
-    assert lm.resolve_target_class("prcxi", "plate", 48, 2200) is None
-
-
-def test_resolve_trash_any():
-    assert lm.resolve_target_class("prcxi", "trash", None, None) == "PRCXI_trash"
-    # trash 规则未约束 hole_count / volume，所以任意值都命中
-    assert lm.resolve_target_class("prcxi", "trash", 0, 0) == "PRCXI_trash"
-
-
-# ==================== YAML 缺失 / 热加载 ====================
-
-
-def test_missing_yaml_uses_builtin(monkeypatch, tmp_path):
-    """YAML 文件不存在时，应自动落到 `_BUILTIN_DEFAULT`，且打 warning。"""
-    bogus = tmp_path / "no_such_labware_mapping.yaml"
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", bogus)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        assert lm.remap_slot("4") == "13"
-        assert (
-            lm.resolve_target_class("prcxi", "plate", 96, None)
-            == "PRCXI_BioER_96_wellplate"
-        )
-    assert any("labware_mapping.yaml 未找到" in str(w.message) for w in caught)
-
-
-def test_invalid_yaml_uses_builtin(monkeypatch, tmp_path):
-    """YAML 解析失败也应回退到 builtin，且打 warning。"""
-    bad = tmp_path / "labware_mapping.yaml"
-    bad.write_text("this is :: not valid: yaml: [unclosed", encoding="utf-8")
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", bad)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        assert lm.remap_slot("4") == "13"
-    assert any(
-        "labware_mapping.yaml 解析失败" in str(w.message)
-        or "labware_mapping.yaml 根不是 dict" in str(w.message)
-        for w in caught
-    )
-
-
-def test_yaml_reload_after_edit(monkeypatch, tmp_path):
-    """临时 YAML 覆盖 + reload_mapping → 新规则生效，且原规则失效（P6.1.1 schema）。"""
-    tmp_yaml = tmp_path / "labware_mapping.yaml"
-    tmp_yaml.write_text(
-        'kinds:\n'
-        "  - { pattern: 'trash', kind: trash }\n"
-        "  - { pattern: '.*',    kind: plate }\n"
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap:\n'
-        '      default: {"4": "99"}\n'
-        '      by_object: {}\n'
-        '    rules:\n'
-        "      - { kind: plate, hole_count: 96, class_name: PRCXI_FooPlate }\n"
-        '  prcxi:\n'
-        '    slot_remap:\n'
-        '      default: {"4": "99"}\n'
-        '      by_object: {}\n'
-        '    rules:\n'
-        "      - { kind: plate, hole_count: 96, class_name: PRCXI_FooPlate }\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", tmp_yaml)
-    lm.reload_mapping()
-    assert lm.remap_slot("4") == "99"
-    assert lm.resolve_target_class("prcxi", "plate", 96, None) == "PRCXI_FooPlate"
-    # 新表里只有 96，没有 384 → None
-    assert lm.resolve_target_class("prcxi", "plate", 384, None) is None
-    # tube_rack / tip_rack 在新表里没规则 → None
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 200) is None
-
-
-def test_missing_section_uses_builtin(monkeypatch, tmp_path):
-    """YAML 缺 `kinds` 段 → 该段使用 builtin，其它段保留用户值（P6.1.1 schema）。"""
-    partial = tmp_path / "labware_mapping.yaml"
-    partial.write_text(
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap:\n'
-        '      default: {"4": "88"}\n'
-        '      by_object: {}\n'
-        '    rules: []\n'
-        '  prcxi:\n'
-        '    slot_remap:\n'
-        '      default: {"4": "88"}\n'
-        '      by_object: {}\n'
-        '    rules: []\n',  # 故意没有 kinds 段
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", partial)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        # slot_remap 用 YAML 中的覆盖值
-        assert lm.remap_slot("4") == "88"
-        # kinds 段缺失 → 使用 builtin 的 tiprack 规则
-        assert lm.infer_kind("opentrons_96_tiprack_300ul") == "tip_rack"
-    assert any("缺少 `kinds` 段" in str(w.message) for w in caught)
-
-
-# ==================== P6.1 新增用例 ====================
-
-
-def test_resolve_target_class_prcxi_tip_buckets():
-    """PRCXI tip 量程档：≤10 / <300 / 否则 1000（与历史 _tip_prcxi_class_for_max_ul 等价）。"""
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 10) == "PRCXI_10uL_Tips"
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 200) == "PRCXI_300ul_Tips"
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 1000) == "PRCXI_1000uL_Tips"
-
-
-def test_resolve_target_class_unknown_device_falls_back_to_default_section():
-    """未声明的 target_device 自动回退到固定段 target_devices.default，打 warning。
-    第一版 default 段内容按 prcxi 拷贝 → 断言：caller 传 'tecan' 时，结果应等于查 default 段。"""
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        # tecan / beckman / 任意未声明名字 → 全部回退到固定段 "default"
-        assert (
-            lm.resolve_target_class("tecan", "tip_rack", 96, 200)
-            == lm.resolve_target_class("default", "tip_rack", 96, 200)
-            == "PRCXI_300ul_Tips"   # 第一版 default 段按 prcxi 填，所以值仍是 PRCXI_*
-        )
-        assert (
-            lm.resolve_target_class("unknown_xxx", "plate", 96, None)
-            == lm.resolve_target_class("default", "plate", 96, None)
-        )
-    # 至少打 1 次 warning，提示「未声明、已回退到 default 段」
-    assert any(
-        ("未在 labware_mapping.yaml" in str(w.message))
-        or ("target_devices.default" in str(w.message))
-        for w in caught
-    )
-
-
-def test_resolve_target_class_per_device_tip_buckets(tmp_path, monkeypatch):
-    """**P6.1 核心断言**：不同 target_device 在同一体积下命中不同 tip 量程档（P6.1.1 schema）。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96,                    class_name: PRCXI_1000uL_Tips}\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 10,    class_name: PRCXI_10uL_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 299.9, class_name: PRCXI_300ul_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96,                    class_name: PRCXI_1000uL_Tips}\n'
-        '  beckman:\n'
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules:\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 20,    class_name: Beckman_20uL_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96, volume_max: 199.9, class_name: Beckman_200uL_Tips}\n'
-        '      - {kind: tip_rack, hole_count: 96,                    class_name: Beckman_1000uL_Tips}\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-
-    # 同样的体积 200：prcxi 走 300 档、beckman 已超出 200 档 → 1000 档
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 200) == "PRCXI_300ul_Tips"
-    assert lm.resolve_target_class("beckman", "tip_rack", 96, 200) == "Beckman_1000uL_Tips"
-    # 同样的体积 15：prcxi 已超出 10 档 → 300 档；beckman 仍在 20 档
-    assert lm.resolve_target_class("prcxi", "tip_rack", 96, 15) == "PRCXI_300ul_Tips"
-    assert lm.resolve_target_class("beckman", "tip_rack", 96, 15) == "Beckman_20uL_Tips"
-
-
-def test_default_section_independent_from_prcxi(tmp_path, monkeypatch):
-    """default 与 prcxi 是两段独立物料集：改 default 不影响 prcxi、改 prcxi 不影响 default。
-
-    断言：把 default 段改成 Generic_Plate96，prcxi 段保持 PRCXI_Plate96 时，
-    caller 传未声明的名字回退到 default 拿 Generic_Plate96，传 prcxi 仍拿 PRCXI_Plate96。
-    """
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'                                                         # ← 独立改 default 段
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules:\n'
-        '      - {kind: plate, hole_count: 96, class_name: Generic_Plate96}\n'
-        '  prcxi:\n'                                                           # ← prcxi 段保持 PRCXI_*
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules:\n'
-        '      - {kind: plate, hole_count: 96, class_name: PRCXI_Plate96}\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-
-    # caller 传未声明的 tecan → 走 default 段 → Generic_*
-    assert lm.resolve_target_class("tecan", "plate", 96, None) == "Generic_Plate96"
-    # caller 显式传 prcxi → 走 prcxi 段 → PRCXI_*（**不**受 default 影响）
-    assert lm.resolve_target_class("prcxi", "plate", 96, None) == "PRCXI_Plate96"
-    # 显式传 "default" 也合法（caller 可主动选择走 default 段）
-    assert lm.resolve_target_class("default", "plate", 96, None) == "Generic_Plate96"
-
-
-def test_legacy_yaml_schema_rejected_with_warning(tmp_path, monkeypatch):
-    """旧 schema（vendors / prcxi_class）应被拒绝 + warning + 整段 fallback 到 builtin（P6.1.1 schema）。"""
-    legacy = tmp_path / "labware_mapping.yaml"
-    legacy.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'vendors:\n'                                                       # ← 旧顶层 key
-        '  opentrons:\n'
-        '    rules:\n'
-        "      - {kind: plate, hole_count: 96, prcxi_class: PRCXI_FooPlate}\n",  # ← 旧字段
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", legacy)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        # 整段走 builtin → 96 板还是 PRCXI_BioER_96_wellplate（**不是**用户旧 YAML 中的 PRCXI_FooPlate）
-        assert lm.resolve_target_class("prcxi", "plate", 96, None) == "PRCXI_BioER_96_wellplate"
-    assert any(
-        ("旧 schema" in str(w.message))
-        or ("vendors" in str(w.message))
-        or ("prcxi_class" in str(w.message))
-        for w in caught
-    )
-
-
-def test_resolve_target_class_unknown_kind_returns_none():
-    """target_device 存在、kind 不存在 → None。"""
-    assert lm.resolve_target_class("prcxi", "reservoir", 12, None) is None
-
-
-# ==================== P6.1.1 新增用例（slot_remap 按 device + model 分叉） ====================
-
-
-def test_remap_slot_model_level_overrides_device_level(tmp_path, monkeypatch):
-    """型号级 slot_remap 优先级 > 厂商级。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {trash: {"12": "16"}}}\n'
-        '    rules: []\n'
-        '    models:\n'
-        '      "4040":\n'
-        '        slot_remap: {default: {"4": "16"}, by_object: {}}\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-    # device 级（不传 model）→ "13"
-    assert lm.remap_slot("4", target_device="prcxi") == "13"
-    # model "4040" 覆盖 → "16"
-    assert lm.remap_slot("4", target_device="prcxi", target_model="4040") == "16"
-    # model "9320" 未声明 → 静默 fallback 到 device 级 → "13"
-    assert lm.remap_slot("4", target_device="prcxi", target_model="9320") == "13"
-
-
-def test_remap_slot_model_inherits_device_when_field_missing(tmp_path, monkeypatch):
-    """model 子段声明但 slot_remap 字段缺失 → 静默继承厂商级；rules 同理。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {}, by_object: {}}\n'
-        '    rules: []\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13", "8": "14"}, by_object: {}}\n'
-        '    rules: [{kind: plate, hole_count: 96, class_name: PRCXI_PlateA}]\n'
-        '    models:\n'
-        '      "9320":\n'
-        '        rules: [{kind: plate, hole_count: 96, class_name: PRCXI_PlateB}]\n',  # 仅覆盖 rules，未声明 slot_remap
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-    # model 9320 的 slot_remap 缺字段 → 继承 prcxi.slot_remap → "4" → "13"
-    assert lm.remap_slot("4", target_device="prcxi", target_model="9320") == "13"
-    # model 9320 的 rules 覆盖 → PRCXI_PlateB
-    assert (
-        lm.resolve_target_class("prcxi", "plate", 96, None, target_model="9320")
-        == "PRCXI_PlateB"
-    )
-    # 不传 model → 用厂商级 rules → PRCXI_PlateA
-    assert lm.resolve_target_class("prcxi", "plate", 96, None) == "PRCXI_PlateA"
-
-
-def test_legacy_top_level_slot_remap_rejected(tmp_path, monkeypatch):
-    """P6.1.1：顶层 slot_remap 段被视为旧 schema → warning + 整段 fallback 到 builtin。"""
-    legacy = tmp_path / "labware_mapping.yaml"
-    legacy.write_text(
-        'slot_remap:\n'                      # ← P6.1.1 已不支持的顶层段
-        '  default: {"4": "99"}\n'
-        '  by_object: {}\n'
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", legacy)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        # 整段走 builtin → "4" 仍然 → "13"（builtin 值），**不是** YAML 顶层的 "99"
-        assert lm.remap_slot("4", target_device="prcxi") == "13"
-    assert any(
-        ("顶层" in str(w.message) and "slot_remap" in str(w.message))
-        or ("旧 schema" in str(w.message))
-        for w in caught
-    )
-
-
-def test_remap_slot_unknown_device_falls_back_with_warning(tmp_path, monkeypatch):
-    """未声明的 target_device → fallback 到 default.slot_remap + warning（与 resolve_target_class 同语义）。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        assert lm.remap_slot("4", target_device="tecan") == "13"  # fallback 到 default
-    assert any(
-        ("tecan" in str(w.message)) or ("target_devices.default" in str(w.message))
-        for w in caught
-    )
-
-
-def test_remap_slot_model_only_no_device_passthrough(tmp_path, monkeypatch):
-    """caller 传 target_model 但 target_device 段不存在 → 直接走 default.slot_remap（model 名忽略）。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n',                          # 没有 prcxi 段
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm.reload_mapping()
-    with warnings.catch_warnings(record=True):
-        warnings.simplefilter("always")
-        # target_device "prcxi" 不存在、target_model 即使传也忽略 → 走 default
-        assert lm.remap_slot("4", target_device="prcxi", target_model="9320") == "13"
-
-
-def test_default_section_models_subsection_warns(tmp_path, monkeypatch):
-    """target_devices.default.models 不被支持 → warning，但 default.slot_remap 仍生效。"""
-    yaml_path = tmp_path / "labware_mapping.yaml"
-    yaml_path.write_text(
-        'kinds: [{pattern: ".*", kind: plate}]\n'
-        'target_devices:\n'
-        '  default:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n'
-        '    models:\n'                              # ← default 段不支持 models
-        '      "ghost":\n'
-        '        slot_remap: {default: {"4": "99"}, by_object: {}}\n'
-        '  prcxi:\n'
-        '    slot_remap: {default: {"4": "13"}, by_object: {}}\n'
-        '    rules: []\n',
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(lm, "_DEFAULT_PATH", yaml_path)
-    lm._load_mapping.cache_clear()
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        # default 段的 models 被忽略 → 走 default.slot_remap → "13"（不是 "99"）
-        assert lm.remap_slot("4", target_device="tecan", target_model="ghost") == "13"
-    assert any(
-        ("default" in str(w.message) and "models" in str(w.message))
-        for w in caught
-    )

tests/workflow/test_wf_utils_workflow_name.py

@@ -1,178 +0,0 @@
-"""``unilabos.workflow.wf_utils.upload_workflow`` 工作流名称 fallback 链单元测试。
-
-对应需求：上传工作流时，**优先取 metadata.workflow_name**；缺失时再回退到顶层
-``workflow_name``（旧 node-link 形态遗留字段）；最后才回退到文件名（去 ``.json`` 后缀）。
-CLI 显式 ``-n/--workflow_name`` 永远最优先。
-
-本测试只校验「**名称 fallback 链 + tags fallback 链**」的纯逻辑路径，
-不实际访问 HTTP / 后端；通过 monkeypatch 把 ``http_client.workflow_import``
-桩成可观察的捕获函数。
-"""
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import pytest
-
-
-# 让 import 走 Uni-Lab-OS 包根
-ROOT = Path(__file__).resolve().parents[2]
-SRC = ROOT / "unilabos"
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-
-@pytest.fixture
-def stub_upload(monkeypatch, tmp_path):
-    """Monkeypatch ``http_client.workflow_import`` + ``_convert_to_node_link``，
-    返回 (helper, captured) 二元组：
-
-    - ``helper(workflow_data, **upload_kwargs)`` 写入 tmp_path/wf.json
-      并调用 ``upload_workflow``；
-    - ``captured`` 是 dict，记录 ``workflow_import`` 实际收到的 kwargs，
-      以及 ``_convert_to_node_link`` 是否被调过。
-
-    本测试不依赖真实 ``unilabos.app.web``（其级联依赖含 ``fastapi`` 等重型
-    package，本地 dev venv 不必装）。通过在 sys.modules 注入空壳 module 拦截
-    delayed import。
-    """
-    import types
-
-    captured: Dict[str, Any] = {"workflow_import_kwargs": None, "converted": False}
-
-    def fake_workflow_import(**kwargs):  # noqa: ANN003
-        captured["workflow_import_kwargs"] = kwargs
-        return {"code": 0, "data": {"uuid": "fake-uuid", "name": kwargs.get("name")}}
-
-    # 关键：在 wf_utils 触发 `from unilabos.app.web import http_client` 之前
-    # 用空壳 module 占位（避免触发真实 web 包的 fastapi 依赖链）。
-    fake_http_client = types.ModuleType("unilabos.app.web.http_client")
-    fake_http_client.workflow_import = fake_workflow_import  # type: ignore[attr-defined]
-    fake_web_pkg = types.ModuleType("unilabos.app.web")
-    fake_web_pkg.http_client = fake_http_client  # type: ignore[attr-defined]
-    monkeypatch.setitem(sys.modules, "unilabos.app.web", fake_web_pkg)
-    monkeypatch.setitem(sys.modules, "unilabos.app.web.http_client", fake_http_client)
-
-    from unilabos.workflow import wf_utils
-
-    # _convert_to_node_link 走真实路径会拉重型依赖，这里桩为 node-link 直返回
-    def fake_convert_to_node_link(workflow_file, workflow_data, *, target_device="prcxi", target_model=None):
-        captured["converted"] = True
-        # 返回最小合法 node-link 形态（不带 metadata，模拟当前行为）
-        return {"nodes": [], "edges": [], "workflow_uuid": ""}
-
-    monkeypatch.setattr(wf_utils, "_convert_to_node_link", fake_convert_to_node_link)
-
-    def helper(workflow_data: Dict[str, Any], **upload_kwargs: Any) -> Dict[str, Any]:
-        wf_path = tmp_path / "transfer_actions_sample.json"
-        wf_path.write_text(json.dumps(workflow_data, ensure_ascii=False), encoding="utf-8")
-        return wf_utils.upload_workflow(str(wf_path), **upload_kwargs)
-
-    return helper, captured
-
-
-# ==================== workflow_name fallback 链 ====================
-
-
-def test_metadata_workflow_name_wins_over_filename(stub_upload):
-    """P5 主路径：transfer_actions JSON 含 metadata.workflow_name → 优先于文件名。"""
-    helper, captured = stub_upload
-    data = {
-        "metadata": {"workflow_name": "PCR Prep with Categories", "tags": []},
-        "workflow": [],
-        "reagent": {},
-    }
-    helper(data)
-    kwargs = captured["workflow_import_kwargs"]
-    assert kwargs is not None and captured["converted"] is True
-    assert kwargs["name"] == "PCR Prep with Categories"
-    assert kwargs["workflow_name"] == "PCR Prep with Categories"
-
-
-def test_cli_workflow_name_overrides_metadata(stub_upload):
-    """CLI 显式 -n/--workflow_name 永远最优先。"""
-    helper, captured = stub_upload
-    data = {
-        "metadata": {"workflow_name": "Metadata Wins By Default"},
-        "workflow": [],
-        "reagent": {},
-    }
-    helper(data, workflow_name="CLI Override Name")
-    kwargs = captured["workflow_import_kwargs"]
-    assert kwargs["name"] == "CLI Override Name"
-    assert kwargs["workflow_name"] == "CLI Override Name"
-
-
-def test_filename_used_when_no_metadata_and_no_legacy(stub_upload):
-    """P5 之前的旧文件、且无顶层 workflow_name → 回退到去 .json 后缀的文件名。"""
-    helper, captured = stub_upload
-    data = {"workflow": [], "reagent": {}}  # 既无 metadata，也无 workflow_name
-    helper(data)
-    kwargs = captured["workflow_import_kwargs"]
-    # 文件名由 fixture 固定为 transfer_actions_sample.json
-    assert kwargs["name"] == "transfer_actions_sample"
-    assert kwargs["workflow_name"] == "transfer_actions_sample"
-
-
-def test_metadata_empty_string_falls_back_to_filename(stub_upload):
-    """metadata.workflow_name 为空字符串（而非缺失）也应回退到文件名。"""
-    helper, captured = stub_upload
-    data = {
-        "metadata": {"workflow_name": "   "},  # whitespace-only
-        "workflow": [],
-        "reagent": {},
-    }
-    helper(data)
-    kwargs = captured["workflow_import_kwargs"]
-    assert kwargs["name"] == "transfer_actions_sample"
-
-
-def test_legacy_top_level_workflow_name_used_when_metadata_missing(stub_upload, monkeypatch):
-    """旧 node-link 文件（已是 nodes/edges 形态）顶层 workflow_name → 应被使用。
-
-    覆盖路径：``_is_node_link_format`` 直接命中 → 不走转换 → workflow_data 保留顶层
-    workflow_name；``orig_metadata`` 为空时 fallback 到该字段。
-    """
-    helper, captured = stub_upload
-    data = {
-        "nodes": [],
-        "edges": [],
-        "workflow_name": "Legacy Top Name",
-    }
-    helper(data)
-    kwargs = captured["workflow_import_kwargs"]
-    assert captured["converted"] is False, "node-link 输入不应触发转换"
-    assert kwargs["name"] == "Legacy Top Name"
-    assert kwargs["workflow_name"] == "Legacy Top Name"
-
-
-# ==================== tags fallback 链 ====================
-
-
-def test_metadata_tags_used_when_cli_tags_missing(stub_upload):
-    """P5 主路径：metadata.tags 在 CLI 未传 tags 时被使用。"""
-    helper, captured = stub_upload
-    data = {
-        "metadata": {"workflow_name": "X", "tags": ["Opentrons", "PCR"]},
-        "workflow": [],
-        "reagent": {},
-    }
-    helper(data)
-    kwargs = captured["workflow_import_kwargs"]
-    assert kwargs["tags"] == ["Opentrons", "PCR"]
-
-
-def test_cli_tags_override_metadata_tags(stub_upload):
-    """CLI 显式 --tags 优先于 metadata.tags。"""
-    helper, captured = stub_upload
-    data = {
-        "metadata": {"workflow_name": "X", "tags": ["Opentrons", "PCR"]},
-        "workflow": [],
-        "reagent": {},
-    }
-    helper(data, tags=["CLI", "Wins"])
-    kwargs = captured["workflow_import_kwargs"]
-    assert kwargs["tags"] == ["CLI", "Wins"]

unilabos/__main__.py

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

unilabos/app/main.py

@@ -336,27 +336,6 @@ def parse_args():
         default="",
         help="Workflow description, used when publishing the workflow",
     )
-    workflow_parser.add_argument(
-        "--target_device",
-        type=str,
-        default="prcxi",
-        help=(
-            "Target instrument name at vendor granularity (e.g. 'prcxi', 'beckman', 'tecan'). "
-            "Decides which target_devices.<name>.rules section in labware_mapping.yaml is used. "
-            "Unknown names fall back to target_devices.default. Default: 'prcxi'."
-        ),
-    )
-    workflow_parser.add_argument(
-        "--target_model",
-        type=str,
-        default=None,
-        help=(
-            "Optional target instrument model name within the same vendor (e.g. '9320', '4040'). "
-            "Used to look up target_devices.<target_device>.models.<target_model>.slot_remap / "
-            ".rules for model-specific deck layout or rule overrides. Falls back to the vendor-level "
-            "configuration when omitted or the model is not declared. Default: None."
-        ),
-    )
     return parser
 
 

unilabos/app/web/controller.py

@@ -58,14 +58,14 @@ class JobResultStore:
                 feedback=feedback or {},
                 timestamp=time.time(),
             )
-            logger.debug(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
+            logger.trace(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.debug(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
+                logger.trace(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
             return result
 
     def get_result(self, job_id: str) -> Optional[JobResult]:

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,42 +201,17 @@ 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描述对象
         """
-        launch_env = self._ensure_ros2_env()
-
+        # 检查ROS 2环境变量
         if "AMENT_PREFIX_PATH" not in os.environ:
             raise OSError(
                 "ROS 2环境未正确设置。需要设置 AMENT_PREFIX_PATH 环境变量。\n"
@@ -315,7 +290,7 @@ class ResourceVisualization:
                         {"robot_description": robot_description},
                         ros2_controllers,
                     ],
-                    env=launch_env,
+                    env=dict(os.environ)
                 )
             )
             for controller in self.moveit_controllers_yaml['moveit_simple_controller_manager']['controller_names']:
@@ -325,7 +300,7 @@ class ResourceVisualization:
                         executable="spawner",
                         arguments=[f"{controller}", "--controller-manager", f"controller_manager"],
                         output="screen",
-                        env=launch_env,
+                        env=dict(os.environ)
                     )
                 )
             controllers.append(
@@ -334,7 +309,7 @@ class ResourceVisualization:
                         executable="spawner",
                         arguments=["joint_state_broadcaster", "--controller-manager", f"controller_manager"],
                         output="screen",
-                        env=launch_env,
+                        env=dict(os.environ)
                 )
             )
             for i in controllers:
@@ -342,6 +317,7 @@ class ResourceVisualization:
         else:
             ros2_controllers = None
 
+        # 创建robot_state_publisher节点
         robot_state_publisher = nd(
             package='robot_state_publisher',
             executable='robot_state_publisher',
@@ -351,8 +327,9 @@ class ResourceVisualization:
                 'robot_description': robot_description,
                 'use_sim_time': False
             },
+            # kinematics_dict
             ],
-            env=launch_env,
+            env=dict(os.environ)
         )
 
 
@@ -384,7 +361,7 @@ class ResourceVisualization:
             executable='move_group',
             output='screen',
             parameters=moveit_params,
-            env=launch_env,
+            env=dict(os.environ)
         )
 
 
@@ -402,11 +379,13 @@ 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=launch_env,
+                env=dict(os.environ)
             )
             self.launch_description.add_action(rviz_node)
 

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

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

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

@@ -1,334 +0,0 @@
-"""
-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,385 +1,307 @@
-      
-import json
+"""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
 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
 
-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
+from unilabos.devices.liquid_handling.laiyu.controllers.xyz_controller import XYZController
+from unilabos.devices.liquid_handling.laiyu.controllers.pipette_controller import (
+    PipetteController,
+    TipStatus,
+)
 
-from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
-from unilabos.devices.liquid_handling.laiyu.controllers.pipette_controller import PipetteController, TipStatus
+logger = logging.getLogger(__name__)
 
 
 class UniLiquidHandlerLaiyuBackend(LiquidHandlerBackend):
-  """Chatter box backend for device-free testing. Prints out all operations."""
+    """LaiYu 硬件后端 — PLR Backend 接口实现"""
 
-  _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
+    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
 
-  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)
+        # 保存配置，延迟到 setup() 再创建硬件对象
+        self._port = port
+        self._baudrate = baudrate
+        self._pipette_address = pipette_address
 
-  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()
+        self._xyz: Optional[XYZController] = None
+        self._pipette_ctrl: Optional[PipetteController] = None
+        self._ros_node = None
 
-    print("Setting up the liquid handler.")
+    # ------------------------------------------------------------------ lifecycle
 
-  async def stop(self):
-    print("Stopping the liquid handler.")
+    def post_init(self, ros_node):
+        """接收 ROS 节点引用（由 Handler.post_init 调用）"""
+        self._ros_node = ros_node
 
-  def serialize(self) -> dict:
-    return {**super().serialize(), "num_channels": self.num_channels}
+    async def setup(self):
+        """按路径 B 顺序初始化硬件"""
+        await super().setup()
 
-  def pipette_aspirate(self, volume: float, flow_rate: float):
+        # 1. XYZ 先开串口
+        self._xyz = XYZController(
+            port=self._port,
+            baudrate=self._baudrate,
+            auto_connect=True,
+        )
+        if not self._xyz.is_connected:
+            raise RuntimeError("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
+        # 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.current_volume += volume 
+        # 3. 回零 + 移液器初始化
+        self._xyz.home_all_axes()
+        self._pipette_ctrl.initialize()
 
-  def pipette_dispense(self, volume: float, flow_rate: float):
+        logger.info("LaiYu 后端硬件初始化完成")
 
-    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
+    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}")
 
-  @property
-  def num_channels(self) -> int:
-    return self._num_channels
+    # ------------------------------------------------------------------ helpers
 
-  async def assigned_resource_callback(self, resource: Resource):
-    print(f"Resource {resource.name} was assigned to the liquid handler.")
+    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 unassigned_resource_callback(self, name: str):
-    print(f"Resource {name} was unassigned from 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 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)
+    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
 
-    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()
+    # ------------------------------------------------------------------ properties
 
+    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 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 assigned_resource_callback(self, resource: Resource):
+        logger.info(f"Resource {resource.name} was assigned to 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)
+    async def unassigned_resource_callback(self, name: str):
+        logger.info(f"Resource {name} was unassigned from the liquid handler.")
 
-    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)  
+    # ------------------------------------------------------------------ pick_up_tips
 
-  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)
+    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)
 
-    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")
+        self._pipette_ctrl._update_tip_status()
+        if self._pipette_ctrl.tip_status == TipStatus.TIP_ATTACHED:
+            logger.warning("已有枪头，无需重复拾取")
+            return
 
-    # 判断枪头是否存在
-    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
+        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.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)
+    # ------------------------------------------------------------------ drop_tips
 
+    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.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)
+        self._pipette_ctrl._update_tip_status()
+        if self._pipette_ctrl.tip_status == TipStatus.NO_TIP:
+            logger.warning("无枪头，无需丢弃")
+            return
 
+        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)
 
-  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)
+        self._pipette_ctrl._update_tip_status()
+        if self._pipette_ctrl.tip_status != TipStatus.TIP_ATTACHED:
+            raise RuntimeError("无枪头，无法吸液")
 
-    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")
+        flow_rate = backend_kwargs.get("flow_rate", 500)
+        blow_out_air_volume = backend_kwargs.get("blow_out_air_volume", 0)
 
-    # 判断枪头是否存在
-    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
+        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.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(x=x, y=y, z=z, speed=200)
+        self._pipette_aspirate(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)
 
-    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)
+    # ------------------------------------------------------------------ dispense
 
-  async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
-    print(f"Picking up tips from {pickup.resource.name}.")
+    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 drop_tips96(self, drop: DropTipRack, **backend_kwargs):
-    print(f"Dropping tips to {drop.resource.name}.")
+        self._pipette_ctrl._update_tip_status()
+        if self._pipette_ctrl.tip_status != TipStatus.TIP_ATTACHED:
+            raise RuntimeError("无枪头，无法排液")
 
-  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}.")
+        flow_rate = backend_kwargs.get("flow_rate", 500)
+        blow_out_air_volume = backend_kwargs.get("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}.")
+        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 pick_up_resource(self, pickup: ResourcePickup):
-    print(f"Picking up resource: {pickup}")
+        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 move_picked_up_resource(self, move: ResourceMove):
-    print(f"Moving picked up resource: {move}")
+        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 drop_resource(self, drop: ResourceDrop):
-    print(f"Dropping resource: {drop}")
+    # ------------------------------------------------------------------ 96-channel stubs
 
-  def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
-    return True
-    
+    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

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

@@ -5,21 +5,16 @@
 封装SOPA移液器的高级控制功能
 """
 
-# 添加项目根目录到Python路径以解决模块导入问题
 import sys
 import os
-from tkinter import N
+
+_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 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
@@ -153,7 +148,7 @@ class PipetteController:
                 logger.error("移液器连接失败")
                 return False
             logger.info("移液器连接成功")
-            
+
             # 连接XYZ步进电机控制器（如果提供了端口）
             if self.xyz_port != self.pipette_port:
                 try:
@@ -172,24 +167,62 @@ 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.info("未配置XYZ步进电机端口，跳过运动控制器连接")
-            
+                    logger.warning(f"共享端口 XYZ 控制器创建失败: {e}")
+                    self.xyz_controller = None
+                    self.xyz_connected = False
+
             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:
@@ -198,56 +231,58 @@ 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
@@ -255,48 +290,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,
@@ -305,28 +340,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
@@ -337,21 +372,20 @@ class PipetteController:
     def emergency_stop(self) -> bool:
         """
         紧急停止所有运动
-        
+
         Returns:
             停止是否成功
         """
         success = True
-        
-        # 停止移液器操作
+
         try:
-            if self.pipette and self.connected:
-                # 这里可以添加移液器的紧急停止逻辑
+            if self.pipette and self.pipette.is_connected:
+                self.pipette.emergency_stop()
                 logger.info("移液器紧急停止")
         except Exception as e:
             logger.error(f"移液器紧急停止失败: {e}")
             success = False
-            
+
         # 停止 XYZ 轴运动
         try:
             if self.xyz_controller and self.xyz_connected:
@@ -360,7 +394,7 @@ class PipetteController:
         except Exception as e:
             logger.error(f"XYZ 轴紧急停止失败: {e}")
             success = False
-            
+
         return success
 
     def pickup_tip(self) -> bool:
@@ -376,7 +410,7 @@ class PipetteController:
             return True
 
         logger.info("开始装载枪头 - Z轴向下移动10mm")
-        
+
         # 使用相对移动方法，向下移动10mm
         if self.move_z_relative(distance_mm=10.0, speed=2000, acceleration=500):
             # 更新枪头状态
@@ -688,31 +722,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:
@@ -721,21 +755,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)
@@ -755,9 +789,9 @@ if __name__ == "__main__":
                 print("99. 🚨 紧急停止")
                 print("0. 🚪 退出程序")
                 print("=" * 50)
-                
+
                 choice = input("\n请选择操作 (0-12, 99): ").strip()
-                
+
                 if choice == "0":
                     print("\n👋 退出程序...")
                     break
@@ -773,7 +807,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🔧 装载枪头...")
@@ -781,14 +815,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🗑️ 弹出枪头...")
@@ -796,7 +830,7 @@ if __name__ == "__main__":
                         print("✅ 枪头弹出成功")
                     else:
                         print("❌ 枪头弹出失败")
-                
+
                 elif choice == "4":
                     # 吸液操作
                     try:
@@ -810,7 +844,7 @@ if __name__ == "__main__":
                             print("❌ 吸液失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-                
+
                 elif choice == "5":
                     # 排液操作
                     try:
@@ -824,7 +858,7 @@ if __name__ == "__main__":
                             print("❌ 排液失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-                
+
                 elif choice == "6":
                     # 混合操作
                     try:
@@ -838,7 +872,7 @@ if __name__ == "__main__":
                             print("❌ 混合失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-                
+
                 elif choice == "7":
                     # 液体转移
                     try:
@@ -846,7 +880,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("✅ 液体转移完成")
@@ -854,7 +888,7 @@ if __name__ == "__main__":
                             print("❌ 液体转移失败")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-                
+
                 elif choice == "8":
                     # 设置液体类型
                     print("\n🧪 可用液体类型:")
@@ -864,16 +898,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"📋 参数设置:")
@@ -883,7 +917,7 @@ if __name__ == "__main__":
                         print(f"  💧 预润湿: {'是' if params.pre_wet else '否'}")
                     else:
                         print("❌ 无效选择")
-                
+
                 elif choice == "9":
                     # 自定义参数
                     try:
@@ -892,19 +926,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:
@@ -914,12 +948,12 @@ if __name__ == "__main__":
                         print(f"✅ 校准完成，校准系数: {actual/expected:.3f}")
                     except ValueError:
                         print("❌ 请输入有效的数字")
-                
+
                 elif choice == "11":
                     # 重置统计
                     pipette.reset_statistics()
                     print("✅ 统计信息已重置")
-                
+
                 elif choice == "12":
                     # 液体类型测试
                     print("\n🧪 液体类型参数对比:")
@@ -929,7 +963,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}):")
@@ -938,7 +972,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🚨 执行紧急停止...")
@@ -949,19 +983,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:
@@ -974,19 +1008,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():
@@ -994,7 +1028,7 @@ if __name__ == "__main__":
             else:
                 print("❌ 设备连接失败")
                 return False
-            
+
             # 初始化设备
             print("\n3. 🚀 初始化设备...")
             if pipette.initialize():
@@ -1002,19 +1036,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
@@ -1023,7 +1057,7 @@ if __name__ == "__main__":
                 print(f"📊 当前体积: {pipette.current_volume}ul")
             else:
                 print("❌ 吸液失败")
-            
+
             # 排液操作
             print("\n7. 💦 执行排液操作...")
             volume_to_dispense = 50.0
@@ -1032,14 +1066,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()
@@ -1052,30 +1086,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)
@@ -1083,9 +1117,9 @@ if __name__ == "__main__":
     print("2. 🎬 演示测试")
     print("0. 🚪 退出")
     print("=" * 40)
-    
+
     mode = input("请选择测试模式 (0-2): ").strip()
-    
+
     if mode == "1":
         interactive_test()
     elif mode == "2":
@@ -1094,7 +1128,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, ChatterBoxBackend, LiquidHandlerChatterboxBackend,
+    MultiHeadAspirationPlate,
 )
 from pylabrobot.liquid_handling.standard import (
     MultiHeadAspirationContainer,
@@ -41,12 +41,6 @@ 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):
@@ -86,7 +80,9 @@ 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, **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,
+                 serial_port: str = "/dev/ttyUSB0", baudrate: int = 115200, pipette_address: int = 4,
+                 total_height: float = 310, **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
@@ -102,11 +98,22 @@ 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 = TransformXYZBackend(name="laiyu",host=host, port=port, timeout=timeout)
+            self._unilabos_backend = UniLiquidHandlerLaiyuBackend(
+                num_channels=channel_num,
+                total_height=total_height,
+                port=serial_port,
+                baudrate=baudrate,
+                pipette_address=pipette_address,
+            )
         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],
@@ -128,7 +135,25 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         mix_liquid_height: Optional[float] = None,
         none_keys: List[str] = [],
     ):
-        pass
+        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,
+        )
 
     async def aspirate(
         self,
@@ -142,7 +167,17 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         spread: Literal["wide", "tight", "custom"] = "wide",
         **backend_kwargs,
     ):
-        pass
+        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,
+        )
 
     async def dispense(
         self,
@@ -156,7 +191,17 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         spread: Literal["wide", "tight", "custom"] = "wide",
         **backend_kwargs,
     ):
-        pass
+        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,
+        )
 
     async def drop_tips(
         self,
@@ -166,7 +211,13 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         allow_nonzero_volume: bool = False,
         **backend_kwargs,
     ):
-        pass
+        return await super().drop_tips(
+            tip_spots=tip_spots,
+            use_channels=use_channels,
+            offsets=offsets,
+            allow_nonzero_volume=allow_nonzero_volume,
+            **backend_kwargs,
+        )
 
     async def mix(
         self,
@@ -178,7 +229,15 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         mix_rate: Optional[float] = None,
         none_keys: List[str] = [],
     ):
-        pass
+        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,
+        )
 
     async def pick_up_tips(
         self,
@@ -187,7 +246,12 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         offsets: Optional[List[Coordinate]] = None,
         **backend_kwargs,
     ):
-        pass
+        return await super().pick_up_tips(
+            tip_spots=tip_spots,
+            use_channels=use_channels,
+            offsets=offsets,
+            **backend_kwargs,
+        )
 
     async def transfer_liquid(
         self,
@@ -214,5 +278,26 @@ class TransformXYZHandler(LiquidHandlerAbstract):
         delays: Optional[List[int]] = None,
         none_keys: List[str] = [],
     ):
-        pass
-    
+        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,
+        )

unilabos/devices/liquid_handling/liquid_history.py

@@ -1,221 +0,0 @@
-"""P9 — liquid_history schema v3 与 helper 函数。
-
-独立模块，**不依赖 pylabrobot**，可在 PLR 环境缺失时单独单测。
-
-模块由 ``liquid_handler_abstract.py`` 在 runtime 挂载点（set_liquid / aspirate /
-dispense）调用，且由 ``resource_tracker._augment_states_with_liquid_history`` 在
-serialize 链路使用。
-
-详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md``。
-"""
-
-from __future__ import annotations
-
-from typing import Any, List, Tuple
-
-from typing_extensions import TypedDict
-
-
-# liquid_history 元素 schema v3
-# 详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md`` §6.1。
-# 旧格式（v2 ``(name, vol)`` 元组、list[str]）由 ``normalize_liquid_history`` 升级。
-class LiquidHistoryEntry(TypedDict, total=False):
-    name: str        # 液体名（如 "Plasma"；与 P8 reagent.liquid_name 联动；缺省 ""）
-    volume: float    # 操作体积（µL；aspirate 为负，dispense / set 为正）
-    action: str      # "set" / "aspirate" / "dispense" / "legacy" / "auto_init"
-    timestamp: str   # ISO8601 UTC（OS runtime 写入时填，前端写入时可省略）
-
-
-# liquid_history 单 well 上限：超过则滚动丢弃头部
-# 既限制内存（典型 8 通道 transfer 一次产生 ≤16 条），也防止极端 batch 拖慢前端渲染
-LIQUID_HISTORY_MAX_ENTRIES = 1000
-
-
-def well_current_liquid_name(well: Any) -> str:
-    """从 ``well.tracker.liquids`` 末项读取当前液体名（PLR ``Liquid`` enum / str / None 兼容）。
-
-    P9：作为 ``aspirate`` 写入 history 时 ``name`` 字段的来源。
-    返回 ``""`` 表示未知（不写字面 "unknown"，避免被前端误展示）。
-    """
-    tracker = getattr(well, "tracker", None)
-    if tracker is None:
-        return ""
-    liquids = getattr(tracker, "liquids", None)
-    if not liquids:
-        # PLR 提供 get_liquids() 时优先用之（返回 list[(Liquid|None, vol)]）
-        try:
-            liquids = tracker.get_liquids()  # type: ignore[attr-defined]
-        except Exception:
-            liquids = None
-    if not liquids:
-        return ""
-    last = liquids[-1]
-    if isinstance(last, (list, tuple)) and last:
-        candidate = last[0]
-    else:
-        candidate = last
-    if candidate is None:
-        return ""
-    name = getattr(candidate, "name", None)
-    if isinstance(name, str) and name:
-        return name
-    if isinstance(candidate, str):
-        return candidate
-    return ""
-
-
-def append_liquid_history(
-    well: Any,
-    liquid_name: str,
-    volume: float,
-    action: str,
-) -> None:
-    """P9 — 统一写入 ``well.tracker.liquid_history``（PLR 扩展属性）。
-
-    设计要点：
-        - 元素为 v3 dict 形态 ``{name, volume, action, timestamp}``，与
-          :class:`LiquidHistoryEntry` schema 一致。
-        - ``aspirate`` 的 ``volume`` 应为**负数**（与 dispense/set 正数对称，
-          ``sum(history.volume)`` ≈ 当前残量）。
-        - ``well`` 无 tracker 或 tracker 不可写时 graceful 静默（避免污染主流程）。
-        - 滚动上限 ``LIQUID_HISTORY_MAX_ENTRIES``：超出时丢弃**头部**（保留最近）。
-
-    详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md`` §6.2。
-    """
-    tracker = getattr(well, "tracker", None)
-    if tracker is None:
-        return
-    history = getattr(tracker, "liquid_history", None)
-    if not isinstance(history, list):
-        history = []
-        try:
-            tracker.liquid_history = history  # type: ignore[attr-defined]
-        except Exception:
-            return  # tracker 拒绝写扩展属性（极少见）；静默放弃
-    # 兼容修复：PLR VolumeTracker.current_liquids 依赖 tracker.liquid_history 为
-    # list[(name, vol)]；若写入 dict 会在 `for name, vol in liquid_history` 时崩溃。
-    # 这里把历史就地归一为 tuple 形态，再 append tuple，避免 unpack ValueError。
-    normalized_pairs: List[Tuple[str, float]] = []
-    for item in history:
-        if isinstance(item, (list, tuple)) and len(item) >= 2:
-            name_val = str(item[0] or "")
-            try:
-                vol_val = float(item[1])
-            except (TypeError, ValueError):
-                vol_val = 0.0
-            normalized_pairs.append((name_val, vol_val))
-        elif isinstance(item, dict):
-            name_val = str(item.get("name", ""))
-            try:
-                vol_val = float(item.get("volume", 0.0) or 0.0)
-            except (TypeError, ValueError):
-                vol_val = 0.0
-            normalized_pairs.append((name_val, vol_val))
-        elif isinstance(item, str):
-            normalized_pairs.append((item, 0.0))
-    history[:] = normalized_pairs
-    entry = (str(liquid_name or ""), float(volume))
-    history.append(entry)
-    overflow = len(history) - LIQUID_HISTORY_MAX_ENTRIES
-    if overflow > 0:
-        del history[:overflow]
-
-
-# ---------------------------------------------------------------------------
-# P10 v2 — Tip 复用 ``tracker.liquids`` 等价 helper（详见
-# ``product_designs/protocol_convert/10-tip-reuse-by-liquid-history.md`` §3.2）
-#
-# 设计原则：
-#   - 信号源使用 PLR 原生 ``well.tracker.liquids`` 末项（"well 此刻顶层液体"），
-#     而非 P9 扩展属性 ``liquid_history``；P10 v2 因此不依赖 P9 是否落地。
-#   - 名称比较使用严格字符串相等；空 / "unknown" / "none" 一律保守视为未知 →
-#     不触发 liquids 复用，落回 identity-only 现状（零回归）。
-#   - 与 P9 现有 ``liquid_names_before_aspirate`` 同模式：aspirate 之前预读
-#     source 当前液体名，避免 PLR 顶层归零时 pop ``liquids`` 拿不到身份。
-#   - 4 个 helper 共同居于本 PLR-free 模块，方便单元测试在不安装 pylabrobot
-#     的环境下独立运行。
-# ---------------------------------------------------------------------------
-
-
-def is_known_liquid_name(name: Any) -> bool:
-    """空字符串 / "unknown" / "none" / None 一律视为未知，不触发 liquids 复用。"""
-    if not name:
-        return False
-    if not isinstance(name, str):
-        return False
-    return name.strip().lower() not in {"unknown", "none"}
-
-
-def same_liquid_via_liquids(well: Any, tip_liquid_name: Any) -> bool:
-    """tip 残留液体名 vs ``well.tracker.liquids`` 末项 name 严格相等。
-
-    用于 pick_up 决策：判断下一轮要 aspirate 的 well 当前液体是否与 tip 残液同名。
-    任一侧未知（空 / "unknown"）→ 返回 ``False``（保守换 tip）。
-    """
-    if not is_known_liquid_name(tip_liquid_name):
-        return False
-    well_name = well_current_liquid_name(well)
-    if not is_known_liquid_name(well_name):
-        return False
-    return well_name == tip_liquid_name
-
-
-def same_liquid_via_liquids_pair(cur_well: Any, next_well: Any) -> bool:
-    """两个 source well 当前 ``tracker.liquids`` 末项是否同名（用于决定 drop 时机）。
-
-    注：必须在 cur_well 的 aspirate **之前**调用；aspirate 不改
-    ``liquids[-1].name`` 只改顶层 vol（或顶层归零时 pop），故 cur/next 的判等
-    以 "将要被抽的那一层" 为准。
-    """
-    cur_name = well_current_liquid_name(cur_well)
-    next_name = well_current_liquid_name(next_well)
-    if not is_known_liquid_name(cur_name) or not is_known_liquid_name(next_name):
-        return False
-    return cur_name == next_name
-
-
-def capture_tip_liquid_name(source_well: Any) -> "str | None":
-    """**aspirate 之前** 把 source well 的当前液体名捕获下来，作为本轮 aspirate
-    完成后 tip 上残留液体的身份。
-
-    必须在 ``super().aspirate`` / ``_transfer_base_method`` 调用前读取：PLR
-    aspirate 会从顶层扣减体积，体积归零时 PLR ``VolumeTracker`` 会 pop 顶层
-    ``(Liquid, vol)``，事后再读 ``liquids[-1]`` 可能拿到 prev layer 或空 list。
-    详见 ``liquid_handler_abstract.aspirate`` 中 ``liquid_names_before_aspirate``
-    同样的 "预读" 模式。
-    """
-    name = well_current_liquid_name(source_well)
-    return name if is_known_liquid_name(name) else None
-
-
-def normalize_liquid_history(raw: Any) -> List[Tuple[str, float]]:
-    """P9 — 把任意旧形态的 liquid_history 升级为 v3 dict 列表。
-
-    兼容输入：
-        - v3 dict： ``[{name, volume, action, timestamp?}, ...]`` 原样返回（字段补全）
-        - v2 tuple： ``[(name, vol), ...]`` → ``action="legacy"``
-        - list[str]： ``["A", "B"]`` → ``volume=0, action="legacy"``
-        - 其它：丢弃该 entry
-
-    详见 ``product_designs/protocol_convert/09-liquid-history-unknown-debug.md`` §6.4。
-    """
-    if not isinstance(raw, list):
-        return []
-    result: List[Tuple[str, float]] = []
-    for entry in raw:
-        if isinstance(entry, dict):
-            try:
-                vol_val = float(entry.get("volume", 0.0) or 0.0)
-            except (TypeError, ValueError):
-                vol_val = 0.0
-            result.append((str(entry.get("name", "")), vol_val))
-        elif isinstance(entry, (list, tuple)) and len(entry) >= 2:
-            try:
-                vol_val = float(entry[1])
-            except (TypeError, ValueError):
-                vol_val = 0.0
-            result.append((str(entry[0] or ""), vol_val))
-        elif isinstance(entry, str):
-            result.append((entry, 0.0))
-        # 其它类型静默丢弃
-    return result

unilabos/devices/liquid_handling/prcxi/prcxi_modules.py

@@ -1,150 +0,0 @@
-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,7 +59,6 @@ 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
@@ -70,7 +69,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     self.joint_state_publisher = LiquidHandlerJointPublisher(
                                 joint_config=self.joint_config,
                                 lh_device_id=self.lh_device_id,
-                                simulate_rviz=self.simulate_rviz)
+                                simulate_rviz=True)
 
     # 启动ROS executor
     self.executor = rclpy.executors.MultiThreadedExecutor()

unilabos/devices/motor/ZDT_X42.py

@@ -0,0 +1,376 @@
+# -*- 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,7 +42,6 @@ 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/ros_dev/moveit_interface.py

@@ -2,7 +2,6 @@ import json
 import time
 from copy import deepcopy
 from pathlib import Path
-from typing import Optional, Sequence
 
 from moveit_msgs.msg import JointConstraint, Constraints
 from rclpy.action import ActionClient
@@ -172,160 +171,173 @@ class MoveitInterface:
 
         return True
 
-    def pick_and_place(
-        self,
-        option: str,
-        move_group: str,
-        status: str,
-        resource: Optional[str] = None,
-        x_distance: Optional[float] = None,
-        y_distance: Optional[float] = None,
-        lift_height: Optional[float] = None,
-        retry: Optional[int] = None,
-        speed: Optional[float] = None,
-        target: Optional[str] = None,
-        constraints: Optional[Sequence[float]] = None,
-    ) -> None:
+    def pick_and_place(self, command: str):
         """
-        使用 MoveIt 完成抓取/放置等序列（pick/place/side_pick/side_place）。
+        Using MoveIt to make the robotic arm pick or place materials to a target point.
 
-        必选：option, move_group, status。
-        可选：resource, x_distance, y_distance, lift_height, retry, speed, target, constraints。
-        无返回值；失败时提前 return 或打印异常。
+        Args:
+            command: A JSON-formatted string that includes option, target, speed, lift_height, mt_height
+
+                    *option (string)    : Action type: pick/place/side_pick/side_place
+                    *move_group (string): The move group moveit will plan
+                    *status(string)     : Target pose
+                    resource(string)    : The target resource
+                    x_distance (float)  : The distance to the target in x direction(meters)
+                    y_distance (float)  : The distance to the target in y direction(meters)
+                    lift_height (float) : The height at which the material should be lifted(meters)
+                    retry (float)       : Retry times when moveit plan fails
+                    speed (float)       : The speed of the movement, speed > 0
+        Returns:
+            None
         """
+        result = SendCmd.Result()
+
         try:
-            if option not in self.move_option:
-                raise ValueError(f"Invalid option: {option}")
+            cmd_str = str(command).replace("'", '"')
+            cmd_dict = json.loads(cmd_str)
 
-            option_index = self.move_option.index(option)
-            place_flag = option_index % 2
+            if cmd_dict["option"] in self.move_option:
+                option_index = self.move_option.index(cmd_dict["option"])
+                place_flag = option_index % 2
 
-            config: dict = {"move_group": move_group}
-            if speed is not None:
-                config["speed"] = speed
-            if retry is not None:
-                config["retry"] = retry
+                config = {}
+                function_list = []
 
-            function_list = []
-            joint_positions_ = self.joint_poses[move_group][status]
+                status = cmd_dict["status"]
+                joint_positions_ = self.joint_poses[cmd_dict["move_group"]][status]
 
-            # 夹取 / 放置：绑定 resource 与 parent
-            if not place_flag:
-                if target is not None:
-                    function_list.append(lambda r=resource, t=target: self.resource_manager(r, t))
-                else:
-                    ee = self.moveit2[move_group].end_effector_name
-                    function_list.append(lambda r=resource: self.resource_manager(r, ee))
-            else:
-                function_list.append(lambda r=resource: self.resource_manager(r, "world"))
+                config.update({k: cmd_dict[k] for k in ["speed", "retry", "move_group"] if k in cmd_dict})
 
-            joint_constraint_msgs: list = []
-            if constraints is not None:
-                for i, c in enumerate(constraints):
-                    v = float(c)
-                    if v > 0:
-                        joint_constraint_msgs.append(
-                            JointConstraint(
-                                joint_name=self.moveit2[move_group].joint_names[i],
-                                position=joint_positions_[i],
-                                tolerance_above=v,
-                                tolerance_below=v,
-                                weight=1.0,
+                # 夹取
+                if not place_flag:
+                    if "target" in cmd_dict.keys():
+                        function_list.append(lambda: self.resource_manager(cmd_dict["resource"], cmd_dict["target"]))
+                    else:
+                        function_list.append(
+                            lambda: self.resource_manager(
+                                cmd_dict["resource"], self.moveit2[cmd_dict["move_group"]].end_effector_name
                             )
                         )
+                else:
+                    function_list.append(lambda: self.resource_manager(cmd_dict["resource"], "world"))
 
-            if lift_height is not None:
-                retval = None
-                attempts = config.get("retry", 10)
-                while retval is None and attempts > 0:
-                    retval = self.moveit2[move_group].compute_fk(joint_positions_)
-                    time.sleep(0.1)
-                    attempts -= 1
-                if retval is None:
-                    raise ValueError("Failed to compute forward kinematics")
-                pose = [retval.pose.position.x, retval.pose.position.y, retval.pose.position.z]
-                quaternion = [
-                    retval.pose.orientation.x,
-                    retval.pose.orientation.y,
-                    retval.pose.orientation.z,
-                    retval.pose.orientation.w,
-                ]
+                constraints = []
+                if "constraints" in cmd_dict.keys():
 
-                function_list = [
-                    lambda: self.moveit_task(
-                        position=[retval.pose.position.x, retval.pose.position.y, retval.pose.position.z],
-                        quaternion=quaternion,
-                        **config,
-                        cartesian=self.cartesian_flag,
-                    )
-                ] + function_list
+                    for i in range(len(cmd_dict["constraints"])):
+                        v = float(cmd_dict["constraints"][i])
+                        if v > 0:
+                            constraints.append(
+                                JointConstraint(
+                                    joint_name=self.moveit2[cmd_dict["move_group"]].joint_names[i],
+                                    position=joint_positions_[i],
+                                    tolerance_above=v,
+                                    tolerance_below=v,
+                                    weight=1.0,
+                                )
+                            )
 
-                pose[2] += float(lift_height)
-                function_list.append(
-                    lambda p=pose.copy(), q=quaternion, cfg=config: self.moveit_task(
-                        position=p, quaternion=q, **cfg, cartesian=self.cartesian_flag
-                    )
-                )
-                end_pose = list(pose)
-
-                if x_distance is not None or y_distance is not None:
-                    if x_distance is not None:
-                        deep_pose = deepcopy(pose)
-                        deep_pose[0] += float(x_distance)
-                    elif y_distance is not None:
-                        deep_pose = deepcopy(pose)
-                        deep_pose[1] += float(y_distance)
+                if "lift_height" in cmd_dict.keys():
+                    retval = None
+                    retry = config.get("retry", 10)
+                    while retval is None and retry > 0:
+                        retval = self.moveit2[cmd_dict["move_group"]].compute_fk(joint_positions_)
+                        time.sleep(0.1)
+                        retry -= 1
+                    if retval is None:
+                        result.success = False
+                        return result
+                    pose = [retval.pose.position.x, retval.pose.position.y, retval.pose.position.z]
+                    quaternion = [
+                        retval.pose.orientation.x,
+                        retval.pose.orientation.y,
+                        retval.pose.orientation.z,
+                        retval.pose.orientation.w,
+                    ]
 
                     function_list = [
-                        lambda p=pose.copy(), q=quaternion, cfg=config: self.moveit_task(
-                            position=p, quaternion=q, **cfg, cartesian=self.cartesian_flag
+                        lambda: self.moveit_task(
+                            position=[retval.pose.position.x, retval.pose.position.y, retval.pose.position.z],
+                            quaternion=quaternion,
+                            **config,
+                            cartesian=self.cartesian_flag,
                         )
                     ] + function_list
+
+                    pose[2] += float(cmd_dict["lift_height"])
                     function_list.append(
-                        lambda dp=deep_pose.copy(), q=quaternion, cfg=config: self.moveit_task(
-                            position=dp, quaternion=q, **cfg, cartesian=self.cartesian_flag
+                        lambda: self.moveit_task(
+                            position=pose, quaternion=quaternion, **config, cartesian=self.cartesian_flag
                         )
                     )
-                    end_pose = list(deep_pose)
+                    end_pose = pose
 
-                retval_ik = None
-                attempts_ik = config.get("retry", 10)
-                while retval_ik is None and attempts_ik > 0:
-                    retval_ik = self.moveit2[move_group].compute_ik(
-                        position=end_pose,
-                        quat_xyzw=quaternion,
-                        constraints=Constraints(joint_constraints=joint_constraint_msgs),
-                    )
-                    time.sleep(0.1)
-                    attempts_ik -= 1
-                if retval_ik is None:
-                    raise ValueError("Failed to compute inverse kinematics")
-                position_ = [
-                    retval_ik.position[retval_ik.name.index(i)] for i in self.moveit2[move_group].joint_names
-                ]
-                jn = self.moveit2[move_group].joint_names
-                function_list = [
-                    lambda pos=position_, names=jn, cfg=config: self.moveit_joint_task(
-                        joint_positions=pos, joint_names=names, **cfg
-                    )
-                ] + function_list
-            else:
-                function_list = [lambda cfg=config, jp=joint_positions_: self.moveit_joint_task(**cfg, joint_positions=jp)] + function_list
+                    if "x_distance" in cmd_dict.keys() or "y_distance" in cmd_dict.keys():
+                        if "x_distance" in cmd_dict.keys():
+                            deep_pose = deepcopy(pose)
+                            deep_pose[0] += float(cmd_dict["x_distance"])
+                        elif "y_distance" in cmd_dict.keys():
+                            deep_pose = deepcopy(pose)
+                            deep_pose[1] += float(cmd_dict["y_distance"])
 
-            for i in range(len(function_list)):
-                if i == 0:
-                    self.cartesian_flag = False
+                        function_list = [
+                            lambda: self.moveit_task(
+                                position=pose, quaternion=quaternion, **config, cartesian=self.cartesian_flag
+                            )
+                        ] + function_list
+                        function_list.append(
+                            lambda: self.moveit_task(
+                                position=deep_pose, quaternion=quaternion, **config, cartesian=self.cartesian_flag
+                            )
+                        )
+                        end_pose = deep_pose
+
+                    retval_ik = None
+                    retry = config.get("retry", 10)
+                    while retval_ik is None and retry > 0:
+                        retval_ik = self.moveit2[cmd_dict["move_group"]].compute_ik(
+                            position=end_pose, quat_xyzw=quaternion, constraints=Constraints(joint_constraints=constraints)
+                        )
+                        time.sleep(0.1)
+                        retry -= 1
+                    if retval_ik is None:
+                        result.success = False
+                        return result
+                    position_ = [
+                        retval_ik.position[retval_ik.name.index(i)]
+                        for i in self.moveit2[cmd_dict["move_group"]].joint_names
+                    ]
+                    function_list = [
+                        lambda: self.moveit_joint_task(
+                            joint_positions=position_,
+                            joint_names=self.moveit2[cmd_dict["move_group"]].joint_names,
+                            **config,
+                        )
+                    ] + function_list
                 else:
-                    self.cartesian_flag = True
+                    function_list = [
+                        lambda: self.moveit_joint_task(**config, joint_positions=joint_positions_)
+                    ] + function_list
 
-                re = function_list[i]()
-                if not re:
-                    print(i, re)
-                    raise ValueError(f"Failed to execute moveit task: {i}")
+                for i in range(len(function_list)):
+                    if i == 0:
+                        self.cartesian_flag = False
+                    else:
+                        self.cartesian_flag = True
+
+                    re = function_list[i]()
+                    if not re:
+                        print(i, re)
+                        result.success = False
+                        return result
+                result.success = True
 
         except Exception as e:
+            print(e)
             self.cartesian_flag = False
-            raise e
+            result.success = False
+
+        return result
 
     def set_status(self, command: str):
         """

unilabos/devices/separator/chinwe.py

@@ -623,6 +623,119 @@ 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

@@ -0,0 +1,379 @@
+# -*- 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/workbench.py

@@ -14,30 +14,20 @@ Virtual Workbench Device - 模拟工作台设备
 
 import logging
 import time
+from typing import Dict, Any, Optional, List
 from dataclasses import dataclass
 from enum import Enum
 from threading import Lock, RLock
-from typing import Any, Dict, List, Optional, cast
 
 from typing_extensions import TypedDict
 
 from unilabos.registry.decorators import (
-    ActionInputHandle,
-    ActionOutputHandle,
-    DataSource,
-    NodeType,
-    action,
-    device,
-    not_action,
-    topic_config,
+    device, action, ActionInputHandle, ActionOutputHandle, DataSource, topic_config, not_action, NodeType
 )
 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.resources.resource_tracker import SampleUUIDsType, LabSample, ResourceTreeSet
+
 
 # ============ TypedDict 返回类型定义 ============
 
@@ -122,7 +112,6 @@ class HeatingStation:
 
 @device(
     id="virtual_workbench",
-    display_name="虚拟工作台",
     category=["virtual_device"],
     description="Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent material processing",
 )
@@ -148,19 +137,7 @@ class VirtualWorkbench:
     HEATING_TIME: float = 60.0  # 加热时间(秒)
     NUM_HEATING_STATIONS: int = 3  # 加热台数量
 
-    def __init__(
-        self,
-        device_id: Optional[str] = None,
-        config: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-        """
-        初始化虚拟工作台。
-
-        Args:
-            device_id[设备ID]: 工作台设备实例 ID，默认使用 virtual_workbench。
-            config[设备配置]: 可包含 arm_operation_time、heating_time、num_heating_stations。
-        """
+    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
         if device_id is None and "id" in kwargs:
             device_id = kwargs.pop("id")
@@ -174,13 +151,9 @@ class VirtualWorkbench:
         self.data: Dict[str, Any] = {}
 
         # 从config中获取可配置参数
-        self.ARM_OPERATION_TIME = float(
-            self.config.get("arm_operation_time", self.ARM_OPERATION_TIME)
-        )
+        self.ARM_OPERATION_TIME = float(self.config.get("arm_operation_time", self.ARM_OPERATION_TIME))
         self.HEATING_TIME = float(self.config.get("heating_time", self.HEATING_TIME))
-        self.NUM_HEATING_STATIONS = int(
-            self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS)
-        )
+        self.NUM_HEATING_STATIONS = int(self.config.get("num_heating_stations", self.NUM_HEATING_STATIONS))
 
         # 机械臂状态和锁
         self._arm_lock = Lock()
@@ -189,8 +162,7 @@ class VirtualWorkbench:
 
         # 加热台状态
         self._heating_stations: Dict[int, HeatingStation] = {
-            i: HeatingStation(station_id=i)
-            for i in range(1, self.NUM_HEATING_STATIONS + 1)
+            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
         }
         self._stations_lock = RLock()
 
@@ -320,113 +292,45 @@ class VirtualWorkbench:
         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,
+        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,
-            ),
+            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,
-            ),
+            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,
-            ),
-        ],
+            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,
@@ -439,156 +343,67 @@ class VirtualWorkbench:
         battery_system: List[str],
         timeout_seconds: int,
         assignee_user_ids: list[str],
-        **kwargs,
+        **kwargs
     ) -> dict:
         """
-        人工确认资源转移和扣电测试参数。
-
-        Args:
-            resource[待转移资源]: 需要人工确认的资源列表。
-            target_device[目标设备]: 资源要转移到的目标设备 ID。
-            mount_resource[目标孔位]: 资源要挂载到的目标孔位列表。
-            collector_mass[极流体质量]: 每个样品对应的极流体质量。
-            active_material[活性物质含量]: 每个样品对应的活性物质含量。
-            capacity[克容量]: 每个样品对应的克容量，单位 mAh/g。
-            battery_system[电池体系]: 每个样品对应的电池体系名称。
-            timeout_seconds[超时时间]: 人工确认超时时间，单位秒。
-            assignee_user_ids[确认人]: 指定处理人工确认任务的用户 ID 列表。
-
-        Note:
-            修改的结果无效，是只读的。
+        timeout_seconds: 超时时间（秒），默认3600秒
+        collector_mass: 极流体质量
+        active_material: 活性物质含量
+        capacity: 克容量（mAh/g）
+        battery_system: 电池体系
+        修改的结果无效，是只读的
         """
-        resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, resource)).dump()
-        mount_resource_tree = ResourceTreeSet.from_plr_resources(cast(Any, mount_resource)).dump()
+        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")
-        kwargs["resource"] = resource_tree
-        kwargs["mount_resource"] = mount_resource_tree
-        kwargs.pop("resource_tree")
-        kwargs.pop("mount_resource_tree")
         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,
-            ),
-        ],
+            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],
-    ):
-        """
-        转移资源到目标设备。
-
-        Args:
-            resource[待转移资源]: 待转移的资源列表。
-            target_device[目标设备]: 接收资源的目标设备 ID。
-            mount_resource[目标孔位]: 目标设备上的挂载孔位列表。
-        """
-        future = ROS2DeviceNode.run_async_func(
-            self._ros_node.transfer_resource_to_another,
-            True,
+    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,
-            ),
-        ],
+            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],
+        self, resource: List[ResourceSlot], mount_resource: List[ResourceSlot],  collector_mass: List[float], active_material: List[float], capacity: List[float], battery_system: list[str]
     ):
-        """
-        启动扣电测试。
-
-        Args:
-            resource[待测试资源]: 需要进行扣电测试的资源列表。
-            mount_resource[测试孔位]: 扣电测试使用的目标孔位列表。
-            collector_mass[极流体质量]: 每个样品对应的极流体质量。
-            active_material[活性物质含量]: 每个样品对应的活性物质含量。
-            capacity[克容量]: 每个样品对应的克容量，单位 mAh/g。
-            battery_system[电池体系]: 每个样品对应的电池体系名称。
-        """
         print(resource)
         print(mount_resource)
         print(collector_mass)
@@ -600,11 +415,16 @@ class VirtualWorkbench:
         auto_prefix=True,
         description="批量准备物料 - 虚拟起始节点, 生成A1-A5物料, 输出5个handle供后续节点使用",
         handles=[
-            ActionOutputHandle(key="channel_1", data_type="workbench_material", label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_2", data_type="workbench_material", label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_3", data_type="workbench_material", label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_4", data_type="workbench_material", label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),  # noqa: E501
-            ActionOutputHandle(key="channel_5", data_type="workbench_material", label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),  # noqa: E501
+            ActionOutputHandle(key="channel_1", data_type="workbench_material",
+                         label="实验1", data_key="material_1", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_2", data_type="workbench_material",
+                         label="实验2", data_key="material_2", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_3", data_type="workbench_material",
+                         label="实验3", data_key="material_3", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_4", data_type="workbench_material",
+                         label="实验4", data_key="material_4", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="channel_5", data_type="workbench_material",
+                         label="实验5", data_key="material_5", data_source=DataSource.EXECUTOR),
         ],
     )
     def prepare_materials(
@@ -617,9 +437,6 @@ class VirtualWorkbench:
 
         作为工作流的起始节点, 生成指定数量的物料编号供后续节点使用。
         输出5个handle (material_1 ~ material_5), 分别对应实验1~5。
-
-        Args:
-            count[物料数量]: 要生成的物料数量，默认生成 5 个。
         """
         materials = [i for i in range(1, count + 1)]
 
@@ -640,11 +457,7 @@ class VirtualWorkbench:
                 LabSample(
                     sample_uuid=sample_uuid,
                     oss_path="",
-                    extra=(
-                        {"material_uuid": content}
-                        if isinstance(content, str)
-                        else (content.serialize() if content else {})
-                    ),
+                    extra={"material_uuid": content} if isinstance(content, str) else (content.serialize() if content else {}),
                 )
                 for sample_uuid, content in sample_uuids.items()
             ],
@@ -654,27 +467,12 @@ class VirtualWorkbench:
         auto_prefix=True,
         description="将物料从An位置移动到空闲加热台, 返回分配的加热台ID",
         handles=[
-            ActionInputHandle(
-                key="material_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionOutputHandle(
-                key="heating_station_output",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="material_number_output",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.EXECUTOR,
-            ),
+            ActionInputHandle(key="material_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
+            ActionOutputHandle(key="heating_station_output", data_type="workbench_station",
+                         label="加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="material_number_output", data_type="workbench_material",
+                         label="物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
         ],
     )
     def move_to_heating_station(
@@ -686,9 +484,6 @@ class VirtualWorkbench:
         将物料从An位置移动到加热台
 
         多线程并发调用时, 会竞争机械臂使用权, 并自动查找空闲加热台
-
-        Args:
-            material_number[物料编号]: 要移动的物料编号，对应 A1、A2 等起始位置。
         """
         material_id = f"A{material_number}"
         task_desc = f"移动{material_id}到加热台"
@@ -751,8 +546,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -775,8 +569,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -788,34 +581,14 @@ class VirtualWorkbench:
         always_free=True,
         description="启动指定加热台的加热程序",
         handles=[
-            ActionInputHandle(
-                key="station_id_input",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="material_number_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionOutputHandle(
-                key="heating_done_station",
-                data_type="workbench_station",
-                label="加热完成-加热台ID",
-                data_key="station_id",
-                data_source=DataSource.EXECUTOR,
-            ),
-            ActionOutputHandle(
-                key="heating_done_material",
-                data_type="workbench_material",
-                label="加热完成-物料编号",
-                data_key="material_number",
-                data_source=DataSource.EXECUTOR,
-            ),
+            ActionInputHandle(key="station_id_input", data_type="workbench_station",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
+            ActionInputHandle(key="material_number_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
+            ActionOutputHandle(key="heating_done_station", data_type="workbench_station",
+                         label="加热完成-加热台ID", data_key="station_id", data_source=DataSource.EXECUTOR),
+            ActionOutputHandle(key="heating_done_material", data_type="workbench_material",
+                         label="加热完成-物料编号", data_key="material_number", data_source=DataSource.EXECUTOR),
         ],
     )
     def start_heating(
@@ -826,10 +599,6 @@ class VirtualWorkbench:
     ) -> StartHeatingResult:
         """
         启动指定加热台的加热程序
-
-        Args:
-            station_id[加热台ID]: 要启动加热的加热台编号。
-            material_number[物料编号]: 当前加热台上的物料编号。
         """
         self.logger.info(f"[加热台{station_id}] 开始加热")
 
@@ -846,8 +615,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -870,8 +638,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -891,8 +658,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -932,9 +698,7 @@ class VirtualWorkbench:
             self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
 
             if time.time() - last_countdown_log >= 5.0:
-                self.logger.info(
-                    f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s"
-                )
+                self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
                 last_countdown_log = time.time()
 
             if elapsed >= self.HEATING_TIME:
@@ -951,9 +715,7 @@ class VirtualWorkbench:
                 self._active_tasks[material_id]["status"] = "heating_completed"
 
         self._update_data_status(f"加热台{station_id}加热完成")
-        self.logger.info(
-            f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)"
-        )
+        self.logger.info(f"[加热台{station_id}] {material_id}加热完成 (用时{self.HEATING_TIME}s)")
 
         return {
             "success": True,
@@ -967,8 +729,7 @@ class VirtualWorkbench:
                     oss_path="",
                     extra=(
                         {"material_uuid": content}
-                        if isinstance(content, str)
-                        else (content.serialize() if content else {})
+                        if isinstance(content, str) else (content.serialize() if content else {})
                     ),
                 )
                 for sample_uuid, content in sample_uuids.items()
@@ -979,20 +740,10 @@ class VirtualWorkbench:
         auto_prefix=True,
         description="将物料从加热台移动到输出位置Cn",
         handles=[
-            ActionInputHandle(
-                key="output_station_input",
-                data_type="workbench_station",
-                label="加热台ID",
-                data_key="station_id",
-                data_source=DataSource.HANDLE,
-            ),
-            ActionInputHandle(
-                key="output_material_input",
-                data_type="workbench_material",
-                label="物料编号",
-                data_key="material_number",
-                data_source=DataSource.HANDLE,
-            ),
+            ActionInputHandle(key="output_station_input", data_type="workbench_station",
+                        label="加热台ID", data_key="station_id", data_source=DataSource.HANDLE),
+            ActionInputHandle(key="output_material_input", data_type="workbench_material",
+                        label="物料编号", data_key="material_number", data_source=DataSource.HANDLE),
         ],
     )
     def move_to_output(
@@ -1003,10 +754,6 @@ class VirtualWorkbench:
     ) -> MoveToOutputResult:
         """
         将物料从加热台移动到输出位置Cn
-
-        Args:
-            station_id[加热台ID]: 已完成加热的加热台编号。
-            material_number[物料编号]: 要移动到输出位置的物料编号，对应 Cn。
         """
         output_number = material_number
 
@@ -1023,8 +770,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()
@@ -1048,8 +794,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -1069,8 +814,7 @@ class VirtualWorkbench:
                             oss_path="",
                             extra=(
                                 {"material_uuid": content}
-                                if isinstance(content, str)
-                                else (content.serialize() if content else {})
+                                if isinstance(content, str) else (content.serialize() if content else {})
                             ),
                         )
                         for sample_uuid, content in sample_uuids.items()
@@ -1152,8 +896,7 @@ class VirtualWorkbench:
                         oss_path="",
                         extra=(
                             {"material_uuid": content}
-                            if isinstance(content, str)
-                            else (content.serialize() if content else {})
+                            if isinstance(content, str) else (content.serialize() if content else {})
                         ),
                     )
                     for sample_uuid, content in sample_uuids.items()

unilabos/devices/workstation/README.md

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

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

@@ -0,0 +1,113 @@
+# 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

@@ -0,0 +1,204 @@
+# 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

@@ -0,0 +1,312 @@
+# 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

@@ -0,0 +1,157 @@
+# 批量出库 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,6 +49,14 @@ 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()
@@ -176,7 +184,40 @@ class BioyondV1RPC(BaseRequest):
             return {}
 
         print(f"add material data: {response['data']}")
-        return response.get("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
 
     def query_matial_type_id(self, data) -> list:
         """查找物料typeid"""
@@ -203,7 +244,7 @@ class BioyondV1RPC(BaseRequest):
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
-                "data": {},
+                "data": 0,
             })
         if not response or response['code'] != 1:
             return []
@@ -273,11 +314,19 @@ 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 = LOCATION_MAPPING.get(location_name, location_name)
+        location_id = self.location_mapping.get(location_name, location_name)
 
         params = {
             "materialId": material_id,
@@ -1103,6 +1152,10 @@ 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}")
@@ -1123,6 +1176,14 @@ 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

@@ -1,142 +0,0 @@
-# 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

@@ -0,0 +1,329 @@
+# 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": "个"
+    # }
+}

unilabos/devices/workstation/bioyond_studio/dispensing_station/dispensing_station.py

@@ -4,7 +4,8 @@ import time
 from typing import Optional, Dict, Any, List
 from typing_extensions import TypedDict
 import requests
-from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
+import pint
+
 
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondException
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
@@ -25,13 +26,89 @@ class ComputeExperimentDesignReturn(TypedDict):
 class BioyondDispensingStation(BioyondWorkstation):
     def __init__(
         self,
-        config,
-            # 桌子
-        deck,
-        *args,
+        config: dict = None,
+        deck=None,
+        protocol_type=None,
         **kwargs,
-        ):
-        super().__init__(config, deck, *args, **kwargs)
+    ):
+        """初始化配液站
+
+        Args:
+            config: 配置字典,应包含material_type_mappings等配置
+            deck: Deck对象
+            protocol_type: 协议类型(由ROS系统传递,此处忽略)
+            **kwargs: 其他可能的参数
+        """
+        if config is None:
+            config = {}
+
+        # 将 kwargs 合并到 config 中 (处理扁平化配置如 api_key)
+        config.update(kwargs)
+
+        if deck is None and config:
+            deck = config.get('deck')
+
+        # 🔧 修复: 确保 Deck 上的 warehouses 具有正确的 UUID (必须在 super().__init__ 之前执行，因为父类会触发同步)
+        # 从配置中读取 warehouse_mapping，并应用到实际的 deck 资源上
+        if config and "warehouse_mapping" in config and deck:
+            warehouse_mapping = config["warehouse_mapping"]
+            print(f"正在根据配置更新 Deck warehouse UUIDs... (共有 {len(warehouse_mapping)} 个配置)")
+
+            user_deck = deck
+            # 初始化 warehouses 字典
+            if not hasattr(user_deck, "warehouses") or user_deck.warehouses is None:
+                user_deck.warehouses = {}
+
+            # 1. 尝试从 children 中查找匹配的资源
+            for child in user_deck.children:
+                # 简单判断: 如果名字在 mapping 中，就认为是 warehouse
+                if child.name in warehouse_mapping:
+                    user_deck.warehouses[child.name] = child
+                    print(f"  - 从子资源中找到 warehouse: {child.name}")
+
+            # 2. 如果还是没找到，且 Deck 类有 setup 方法，尝试调用 setup (针对 Deck 对象正确但未初始化的情况)
+            if not user_deck.warehouses and hasattr(user_deck, "setup"):
+                print("  - 尝试调用 deck.setup() 初始化仓库...")
+                try:
+                    user_deck.setup()
+                    # setup 后重新检查
+                    if hasattr(user_deck, "warehouses") and user_deck.warehouses:
+                            print(f"  - setup() 成功，找到 {len(user_deck.warehouses)} 个仓库")
+                except Exception as e:
+                    print(f"  - 调用 setup() 失败: {e}")
+
+            # 3. 如果仍然为空，可能需要手动创建 (仅针对特定已知的 Deck 类型进行补救，这里暂时只打印警告)
+            if not user_deck.warehouses:
+                    print("  - ⚠️ 仍然无法找到任何 warehouse 资源！")
+
+            for wh_name, wh_config in warehouse_mapping.items():
+                target_uuid = wh_config.get("uuid")
+
+                # 尝试在 deck.warehouses 中查找
+                wh_resource = None
+                if hasattr(user_deck, "warehouses") and wh_name in user_deck.warehouses:
+                    wh_resource = user_deck.warehouses[wh_name]
+
+                # 如果没找到，尝试在所有子资源中查找
+                if not wh_resource:
+                    wh_resource = user_deck.get_resource(wh_name)
+
+                if wh_resource:
+                    if target_uuid:
+                        current_uuid = getattr(wh_resource, "uuid", None)
+                        print(f"✅ 更新仓库 '{wh_name}' UUID: {current_uuid} -> {target_uuid}")
+
+                        # 动态添加 uuid 属性
+                        wh_resource.uuid = target_uuid
+                        # 同时也确保 category 正确，避免 graphio 识别错误
+                        # wh_resource.category = "warehouse"
+                    else:
+                            print(f"⚠️ 仓库 '{wh_name}' 在配置中没有 UUID")
+                else:
+                    print(f"❌ 在 Deck 中未找到配置的仓库: '{wh_name}'")
+
+        super().__init__(bioyond_config=config, deck=deck)
+
         # self.config = config
         # self.api_key = config["api_key"]
         # self.host = config["api_host"]
@@ -43,6 +120,41 @@ class BioyondDispensingStation(BioyondWorkstation):
         # 用于跟踪任务完成状态的字典: {orderCode: {status, order_id, timestamp}}
         self.order_completion_status = {}
 
+        # 初始化 pint 单位注册表
+        self.ureg = pint.UnitRegistry()
+
+        # 化合物信息
+        self.compound_info = {
+            "MolWt": {
+                "MDA": 108.14 * self.ureg.g / self.ureg.mol,
+                "TDA": 122.16 * self.ureg.g / self.ureg.mol,
+                "PAPP": 521.62 * self.ureg.g / self.ureg.mol,
+                "BTDA": 322.23 * self.ureg.g / self.ureg.mol,
+                "BPDA": 294.22 * self.ureg.g / self.ureg.mol,
+                "6FAP": 366.26 * self.ureg.g / self.ureg.mol,
+                "PMDA": 218.12 * self.ureg.g / self.ureg.mol,
+                "MPDA": 108.14 * self.ureg.g / self.ureg.mol,
+                "SIDA": 248.51 * self.ureg.g / self.ureg.mol,
+                "ODA": 200.236 * self.ureg.g / self.ureg.mol,
+                "4,4'-ODA": 200.236 * self.ureg.g / self.ureg.mol,
+                "134": 292.34 * self.ureg.g / self.ureg.mol,
+            },
+            "FuncGroup": {
+                "MDA": "Amine",
+                "TDA": "Amine",
+                "PAPP": "Amine",
+                "BTDA": "Anhydride",
+                "BPDA": "Anhydride",
+                "6FAP": "Amine",
+                "MPDA": "Amine",
+                "SIDA": "Amine",
+                "PMDA": "Anhydride",
+                "ODA": "Amine",
+                "4,4'-ODA": "Amine",
+                "134": "Amine",
+            }
+        }
+
     def _post_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
         """项目接口通用POST调用
 
@@ -54,7 +166,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             dict: 服务端响应，失败时返回 {code:0,message,...}
         """
         request_data = {
-            "apiKey": API_CONFIG["api_key"],
+            "apiKey": self.bioyond_config["api_key"],
             "requestTime": self.hardware_interface.get_current_time_iso8601(),
             "data": data
         }
@@ -85,7 +197,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             dict: 服务端响应，失败时返回 {code:0,message,...}
         """
         request_data = {
-            "apiKey": API_CONFIG["api_key"],
+            "apiKey": self.bioyond_config["api_key"],
             "requestTime": self.hardware_interface.get_current_time_iso8601(),
             "data": data
         }
@@ -118,20 +230,22 @@ class BioyondDispensingStation(BioyondWorkstation):
                     ratio = json.loads(ratio)
                 except Exception:
                     ratio = {}
-            root = str(Path(__file__).resolve().parents[3])
-            if root not in sys.path:
-                sys.path.append(root)
-            try:
-                mod = importlib.import_module("tem.compute")
-            except Exception as e:
-                raise BioyondException(f"无法导入计算模块: {e}")
             try:
                 wp = float(wt_percent) if isinstance(wt_percent, str) else wt_percent
                 mt = float(m_tot) if isinstance(m_tot, str) else m_tot
                 tp = float(titration_percent) if isinstance(titration_percent, str) else titration_percent
             except Exception as e:
                 raise BioyondException(f"参数解析失败: {e}")
-            res = mod.generate_experiment_design(ratio=ratio, wt_percent=wp, m_tot=mt, titration_percent=tp)
+
+            # 2. 调用内部计算方法
+            res = self._generate_experiment_design(
+                ratio=ratio,
+                wt_percent=wp,
+                m_tot=mt,
+                titration_percent=tp
+            )
+
+            # 3. 构造返回结果
             out = {
                 "solutions": res.get("solutions", []),
                 "titration": res.get("titration", {}),
@@ -140,11 +254,248 @@ class BioyondDispensingStation(BioyondWorkstation):
                 "return_info": json.dumps(res, ensure_ascii=False)
             }
             return out
+
         except BioyondException:
             raise
         except Exception as e:
             raise BioyondException(str(e))
 
+    def _generate_experiment_design(
+        self,
+        ratio: dict,
+        wt_percent: float = 0.25,
+        m_tot: float = 70,
+        titration_percent: float = 0.03,
+    ) -> dict:
+        """内部方法：生成实验设计
+
+        根据FuncGroup自动区分二胺和二酐，每种二胺单独配溶液，严格按照ratio顺序投料。
+
+        参数:
+            ratio: 化合物配比字典，格式: {"compound_name": ratio_value}
+            wt_percent: 固体重量百分比
+            m_tot: 反应混合物总质量(g)
+            titration_percent: 滴定溶液百分比
+
+        返回:
+            包含实验设计详细参数的字典
+        """
+        # 溶剂密度
+        ρ_solvent = 1.03 * self.ureg.g / self.ureg.ml
+        # 二酐溶解度
+        solubility = 0.02 * self.ureg.g / self.ureg.ml
+        # 投入固体时最小溶剂体积
+        V_min = 30 * self.ureg.ml
+        m_tot = m_tot * self.ureg.g
+
+        # 保持ratio中的顺序
+        compound_names = list(ratio.keys())
+        compound_ratios = list(ratio.values())
+
+        # 验证所有化合物是否在 compound_info 中定义
+        undefined_compounds = [name for name in compound_names if name not in self.compound_info["MolWt"]]
+        if undefined_compounds:
+            available = list(self.compound_info["MolWt"].keys())
+            raise ValueError(
+                f"以下化合物未在 compound_info 中定义: {undefined_compounds}。"
+                f"可用的化合物: {available}"
+            )
+
+        # 获取各化合物的分子量和官能团类型
+        molecular_weights = [self.compound_info["MolWt"][name] for name in compound_names]
+        func_groups = [self.compound_info["FuncGroup"][name] for name in compound_names]
+
+        # 记录化合物信息用于调试
+        self.hardware_interface._logger.info(f"化合物名称: {compound_names}")
+        self.hardware_interface._logger.info(f"官能团类型: {func_groups}")
+
+        # 按原始顺序分离二胺和二酐
+        ordered_compounds = list(zip(compound_names, compound_ratios, molecular_weights, func_groups))
+        diamine_compounds = [(name, ratio_val, mw, i) for i, (name, ratio_val, mw, fg) in enumerate(ordered_compounds) if fg == "Amine"]
+        anhydride_compounds = [(name, ratio_val, mw, i) for i, (name, ratio_val, mw, fg) in enumerate(ordered_compounds) if fg == "Anhydride"]
+
+        if not diamine_compounds or not anhydride_compounds:
+            raise ValueError(
+                f"需要同时包含二胺(Amine)和二酐(Anhydride)化合物。"
+                f"当前二胺: {[c[0] for c in diamine_compounds]}, "
+                f"当前二酐: {[c[0] for c in anhydride_compounds]}"
+            )
+
+        # 计算加权平均分子量 (基于摩尔比)
+        total_molar_ratio = sum(compound_ratios)
+        weighted_molecular_weight = sum(ratio_val * mw for ratio_val, mw in zip(compound_ratios, molecular_weights))
+
+        # 取最后一个二酐用于滴定
+        titration_anhydride = anhydride_compounds[-1]
+        solid_anhydrides = anhydride_compounds[:-1] if len(anhydride_compounds) > 1 else []
+
+        # 二胺溶液配制参数 - 每种二胺单独配制
+        diamine_solutions = []
+        total_diamine_volume = 0 * self.ureg.ml
+
+        # 计算反应物的总摩尔量
+        n_reactant = m_tot * wt_percent / weighted_molecular_weight
+
+        for name, ratio_val, mw, order_index in diamine_compounds:
+            # 跳过 SIDA
+            if name == "SIDA":
+                continue
+
+            # 计算该二胺需要的摩尔数
+            n_diamine_needed = n_reactant * ratio_val
+
+            # 二胺溶液配制参数 (每种二胺固定配制参数)
+            m_diamine_solid = 5.0 * self.ureg.g  # 每种二胺固体质量
+            V_solvent_for_this = 20 * self.ureg.ml  # 每种二胺溶剂体积
+            m_solvent_for_this = ρ_solvent * V_solvent_for_this
+
+            # 计算该二胺溶液的浓度
+            c_diamine = (m_diamine_solid / mw) / V_solvent_for_this
+
+            # 计算需要移取的溶液体积
+            V_diamine_needed = n_diamine_needed / c_diamine
+
+            diamine_solutions.append({
+                "name": name,
+                "order": order_index,
+                "solid_mass": m_diamine_solid.magnitude,
+                "solvent_volume": V_solvent_for_this.magnitude,
+                "concentration": c_diamine.magnitude,
+                "volume_needed": V_diamine_needed.magnitude,
+                "molar_ratio": ratio_val
+            })
+
+            total_diamine_volume += V_diamine_needed
+
+        # 按原始顺序排序
+        diamine_solutions.sort(key=lambda x: x["order"])
+
+        # 计算滴定二酐的质量
+        titration_name, titration_ratio, titration_mw, _ = titration_anhydride
+        m_titration_anhydride = n_reactant * titration_ratio * titration_mw
+        m_titration_90 = m_titration_anhydride * (1 - titration_percent)
+        m_titration_10 = m_titration_anhydride * titration_percent
+
+        # 计算其他固体二酐的质量 (按顺序)
+        solid_anhydride_masses = []
+        for name, ratio_val, mw, order_index in solid_anhydrides:
+            mass = n_reactant * ratio_val * mw
+            solid_anhydride_masses.append({
+                "name": name,
+                "order": order_index,
+                "mass": mass.magnitude,
+                "molar_ratio": ratio_val
+            })
+
+        # 按原始顺序排序
+        solid_anhydride_masses.sort(key=lambda x: x["order"])
+
+        # 计算溶剂用量
+        total_diamine_solution_mass = sum(
+            sol["volume_needed"] * ρ_solvent for sol in diamine_solutions
+        ) * self.ureg.ml
+
+        # 预估滴定溶剂量、计算补加溶剂量
+        m_solvent_titration = m_titration_10 / solubility * ρ_solvent
+        m_solvent_add = m_tot * (1 - wt_percent) - total_diamine_solution_mass - m_solvent_titration
+
+        # 检查最小溶剂体积要求
+        total_liquid_volume = (total_diamine_solution_mass + m_solvent_add) / ρ_solvent
+        m_tot_min = V_min / total_liquid_volume * m_tot
+
+        # 如果需要，按比例放大
+        scale_factor = 1.0
+        if m_tot_min > m_tot:
+            scale_factor = (m_tot_min / m_tot).magnitude
+            m_titration_90 *= scale_factor
+            m_titration_10 *= scale_factor
+            m_solvent_add *= scale_factor
+            m_solvent_titration *= scale_factor
+
+            # 更新二胺溶液用量
+            for sol in diamine_solutions:
+                sol["volume_needed"] *= scale_factor
+
+            # 更新固体二酐用量
+            for anhydride in solid_anhydride_masses:
+                anhydride["mass"] *= scale_factor
+
+            m_tot = m_tot_min
+
+        # 生成投料顺序
+        feeding_order = []
+
+        # 1. 固体二酐 (按顺序)
+        for anhydride in solid_anhydride_masses:
+            feeding_order.append({
+                "step": len(feeding_order) + 1,
+                "type": "solid_anhydride",
+                "name": anhydride["name"],
+                "amount": anhydride["mass"],
+                "order": anhydride["order"]
+            })
+
+        # 2. 二胺溶液 (按顺序)
+        for sol in diamine_solutions:
+            feeding_order.append({
+                "step": len(feeding_order) + 1,
+                "type": "diamine_solution",
+                "name": sol["name"],
+                "amount": sol["volume_needed"],
+                "order": sol["order"]
+            })
+
+        # 3. 主要二酐粉末
+        feeding_order.append({
+            "step": len(feeding_order) + 1,
+            "type": "main_anhydride",
+            "name": titration_name,
+            "amount": m_titration_90.magnitude,
+            "order": titration_anhydride[3]
+        })
+
+        # 4. 补加溶剂
+        if m_solvent_add > 0:
+            feeding_order.append({
+                "step": len(feeding_order) + 1,
+                "type": "additional_solvent",
+                "name": "溶剂",
+                "amount": m_solvent_add.magnitude,
+                "order": 999
+            })
+
+        # 5. 滴定二酐溶液
+        feeding_order.append({
+            "step": len(feeding_order) + 1,
+            "type": "titration_anhydride",
+            "name": f"{titration_name} 滴定液",
+            "amount": m_titration_10.magnitude,
+            "titration_solvent": m_solvent_titration.magnitude,
+            "order": titration_anhydride[3]
+        })
+
+        # 返回实验设计结果
+        results = {
+            "total_mass": m_tot.magnitude,
+            "scale_factor": scale_factor,
+            "solutions": diamine_solutions,
+            "solids": solid_anhydride_masses,
+            "titration": {
+                "name": titration_name,
+                "main_portion": m_titration_90.magnitude,
+                "titration_portion": m_titration_10.magnitude,
+                "titration_solvent": m_solvent_titration.magnitude,
+            },
+            "solvents": {
+                "additional_solvent": m_solvent_add.magnitude,
+                "total_liquid_volume": total_liquid_volume.magnitude
+            },
+            "feeding_order": feeding_order,
+            "minimum_required_mass": m_tot_min.magnitude
+        }
+
+        return results
+
     # 90%10%小瓶投料任务创建方法
     def create_90_10_vial_feeding_task(self,
                                        order_name: str = None,
@@ -961,6 +1312,108 @@ class BioyondDispensingStation(BioyondWorkstation):
             'actualVolume': actual_volume
         }
 
+    def _simplify_report(self, report) -> Dict[str, Any]:
+        """简化实验报告，只保留关键信息，去除冗余的工作流参数"""
+        if not isinstance(report, dict):
+            return report
+
+        data = report.get('data', {})
+        if not isinstance(data, dict):
+            return report
+
+        # 提取关键信息
+        simplified = {
+            'name': data.get('name'),
+            'code': data.get('code'),
+            'requester': data.get('requester'),
+            'workflowName': data.get('workflowName'),
+            'workflowStep': data.get('workflowStep'),
+            'requestTime': data.get('requestTime'),
+            'startPreparationTime': data.get('startPreparationTime'),
+            'completeTime': data.get('completeTime'),
+            'useTime': data.get('useTime'),
+            'status': data.get('status'),
+            'statusName': data.get('statusName'),
+        }
+
+        # 提取物料信息（简化版）
+        pre_intakes = data.get('preIntakes', [])
+        if pre_intakes and isinstance(pre_intakes, list):
+            first_intake = pre_intakes[0]
+            sample_materials = first_intake.get('sampleMaterials', [])
+
+            # 简化物料信息
+            simplified_materials = []
+            for material in sample_materials:
+                if isinstance(material, dict):
+                    mat_info = {
+                        'materialName': material.get('materialName'),
+                        'materialTypeName': material.get('materialTypeName'),
+                        'materialCode': material.get('materialCode'),
+                        'materialLocation': material.get('materialLocation'),
+                    }
+
+                    # 解析parameters中的关键信息（如密度、加料历史等）
+                    params_str = material.get('parameters', '{}')
+                    try:
+                        params = json.loads(params_str) if isinstance(params_str, str) else params_str
+                        if isinstance(params, dict):
+                            # 只保留关键参数
+                            if 'density' in params:
+                                mat_info['density'] = params['density']
+                            if 'feedingHistory' in params:
+                                mat_info['feedingHistory'] = params['feedingHistory']
+                            if 'liquidVolume' in params:
+                                mat_info['liquidVolume'] = params['liquidVolume']
+                            if 'm_diamine_tot' in params:
+                                mat_info['m_diamine_tot'] = params['m_diamine_tot']
+                            if 'wt_diamine' in params:
+                                mat_info['wt_diamine'] = params['wt_diamine']
+                    except:
+                        pass
+
+                    simplified_materials.append(mat_info)
+
+            simplified['sampleMaterials'] = simplified_materials
+
+            # 提取extraProperties中的实际值
+            extra_props = first_intake.get('extraProperties', {})
+            if isinstance(extra_props, dict):
+                simplified_extra = {}
+                for key, value in extra_props.items():
+                    try:
+                        parsed_value = json.loads(value) if isinstance(value, str) else value
+                        simplified_extra[key] = parsed_value
+                    except:
+                        simplified_extra[key] = value
+                simplified['extraProperties'] = simplified_extra
+
+        return {
+            'data': simplified,
+            'code': report.get('code'),
+            'message': report.get('message'),
+            'timestamp': report.get('timestamp')
+        }
+
+    def scheduler_start(self) -> dict:
+        """启动调度器 - 启动Bioyond工作站的任务调度器，开始执行队列中的任务
+
+        Returns:
+            dict: 包含return_info的字典，return_info为整型(1=成功)
+
+        Raises:
+            BioyondException: 调度器启动失败时抛出异常
+        """
+        result = self.hardware_interface.scheduler_start()
+        self.hardware_interface._logger.info(f"调度器启动结果: {result}")
+
+        if result != 1:
+            error_msg = "启动调度器失败: 有未处理错误，调度无法启动。请检查Bioyond系统状态。"
+            self.hardware_interface._logger.error(error_msg)
+            raise BioyondException(error_msg)
+
+        return {"return_info": result}
+
     # 等待多个任务完成并获取实验报告
     def wait_for_multiple_orders_and_get_reports(self,
                                                   batch_create_result: str = None,
@@ -1002,7 +1455,12 @@ class BioyondDispensingStation(BioyondWorkstation):
 
             # 验证batch_create_result参数
             if not batch_create_result or batch_create_result == "":
-                raise BioyondException("batch_create_result参数为空，请确保从batch_create节点正确连接handle")
+                raise BioyondException(
+                    "batch_create_result参数为空，请确保:\n"
+                    "1. batch_create节点与wait节点之间正确连接了handle\n"
+                    "2. batch_create节点成功执行并返回了结果\n"
+                    "3. 检查上游batch_create任务是否成功创建了订单"
+                )
 
             # 解析batch_create_result JSON对象
             try:
@@ -1031,7 +1489,17 @@ class BioyondDispensingStation(BioyondWorkstation):
 
             # 验证提取的数据
             if not order_codes:
-                raise BioyondException("batch_create_result中未找到order_codes字段或为空")
+                self.hardware_interface._logger.error(
+                    f"batch_create任务未生成任何订单。batch_create_result内容: {batch_create_result}"
+                )
+                raise BioyondException(
+                    "batch_create_result中未找到order_codes或为空。\n"
+                    "可能的原因:\n"
+                    "1. batch_create任务执行失败（检查任务是否报错）\n"
+                    "2. 物料配置问题（如'物料样品板分配失败'）\n"
+                    "3. Bioyond系统状态异常\n"
+                    f"请检查batch_create任务的执行结果"
+                )
             if not order_ids:
                 raise BioyondException("batch_create_result中未找到order_ids字段或为空")
 
@@ -1114,6 +1582,8 @@ class BioyondDispensingStation(BioyondWorkstation):
                                 self.hardware_interface._logger.info(
                                     f"成功获取任务 {order_code} 的实验报告"
                                 )
+                                # 简化报告，去除冗余信息
+                                report = self._simplify_report(report)
 
                             reports.append({
                                 "order_code": order_code,
@@ -1288,7 +1758,7 @@ class BioyondDispensingStation(BioyondWorkstation):
                 f"开始执行批量物料转移: {len(transfer_groups)}组任务 -> {target_device_id}"
             )
 
-            from .config import WAREHOUSE_MAPPING
+            warehouse_mapping = self.bioyond_config.get("warehouse_mapping", {})
             results = []
             successful_count = 0
             failed_count = 0

unilabos/devices/workstation/bioyond_studio/station.py

@@ -6,6 +6,7 @@ Bioyond Workstation Implementation
 """
 import time
 import traceback
+import threading
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -23,12 +24,94 @@ from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
 from unilabos.ros.msgs.message_converter import convert_to_ros_msg, Float64, String
 from pylabrobot.resources.resource import Resource as ResourcePLR
 
-from unilabos.devices.workstation.bioyond_studio.config import (
-    API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING, HTTP_SERVICE_CONFIG
-)
+
 from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
 
 
+class ConnectionMonitor:
+    """Bioyond连接监控器"""
+    def __init__(self, workstation, check_interval=30):
+        self.workstation = workstation
+        self.check_interval = check_interval
+        self._running = False
+        self._thread = None
+        self._last_status = "unknown"
+
+    def start(self):
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._monitor_loop, daemon=True, name="BioyondConnectionMonitor")
+        self._thread.start()
+        logger.info("Bioyond连接监控器已启动")
+
+    def stop(self):
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2)
+            logger.info("Bioyond连接监控器已停止")
+
+    def _monitor_loop(self):
+        while self._running:
+            try:
+                # 使用 lightweight API 检查连接
+                # query_matial_type_list 是比较快的查询
+                start_time = time.time()
+                result = self.workstation.hardware_interface.material_type_list()
+
+                status = "online" if result else "offline"
+                msg = "Connection established" if status == "online" else "Failed to get material type list"
+
+                if status != self._last_status:
+                    logger.info(f"Bioyond连接状态变更: {self._last_status} -> {status}")
+                    self._publish_event(status, msg)
+                    self._last_status = status
+
+                # 发布心跳 (可选，或者只在状态变更时发布)
+                # self._publish_event(status, msg)
+
+            except Exception as e:
+                logger.error(f"Bioyond连接检查异常: {e}")
+                if self._last_status != "error":
+                    self._publish_event("error", str(e))
+                    self._last_status = "error"
+
+            time.sleep(self.check_interval)
+
+    def _publish_event(self, status, message):
+        try:
+            if hasattr(self.workstation, "_ros_node") and self.workstation._ros_node:
+                event_data = {
+                    "status": status,
+                    "message": message,
+                    "timestamp": datetime.now().isoformat()
+                }
+
+                # 动态发布消息，需要在 ROS2DeviceNode 中有对应支持
+                # 这里假设通用事件发布机制，使用 String 类型的 topic
+                # 话题: /<namespace>/events/device_status
+                ns = self.workstation._ros_node.namespace
+                topic = f"{ns}/events/device_status"
+
+                # 使用 ROS2DeviceNode 的发布功能
+                # 如果没有预定义的 publisher，需要动态创建
+                # 注意：workstation base node 可能没有自动创建 arbitrary publishers 的机制
+                # 这里我们先尝试用 String json 发布
+
+                # 在 ROS2DeviceNode 中通常需要先 create_publisher
+                # 为了简单起见，我们检查是否已有 publisher，没有则创建
+                if not hasattr(self.workstation, "_device_status_pub"):
+                    self.workstation._device_status_pub = self.workstation._ros_node.create_publisher(
+                        String, topic, 10
+                    )
+
+                self.workstation._device_status_pub.publish(
+                    convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
+                )
+        except Exception as e:
+            logger.error(f"发布设备状态事件失败: {e}")
+
+
 class BioyondResourceSynchronizer(ResourceSynchronizer):
     """Bioyond资源同步器
 
@@ -174,9 +257,8 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             else:
                 logger.info(f"[同步→Bioyond] ➕ 物料不存在于 Bioyond，将创建新物料并入库")
 
-            # 第1步：获取仓库配置
-            from .config import WAREHOUSE_MAPPING
-            warehouse_mapping = WAREHOUSE_MAPPING
+            # 第1步：从配置中获取仓库配置
+            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
 
             # 确定目标仓库名称
             parent_name = None
@@ -238,14 +320,20 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             # 第2步：转换为 Bioyond 格式
             logger.info(f"[同步→Bioyond] 🔄 转换物料为 Bioyond 格式...")
 
-            # 导入物料默认参数配置
-            from .config import MATERIAL_DEFAULT_PARAMETERS
+            # 从配置中获取物料默认参数
+            material_default_params = self.workstation.bioyond_config.get("material_default_parameters", {})
+            material_type_params = self.workstation.bioyond_config.get("material_type_parameters", {})
+
+            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
+            merged_params = material_default_params.copy()
+            for type_id, params in material_type_params.items():
+                merged_params[f"type:{type_id}"] = params
 
             bioyond_material = resource_plr_to_bioyond(
                 [resource],
                 type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                 warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=MATERIAL_DEFAULT_PARAMETERS
+                material_params=merged_params
             )[0]
 
             logger.info(f"[同步→Bioyond] 🔧 准备覆盖locations字段，目标仓库: {parent_name}, 库位: {update_site}, UUID: {target_location_uuid[:8]}...")
@@ -468,13 +556,20 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 return material_bioyond_id
 
             # 转换为 Bioyond 格式
-            from .config import MATERIAL_DEFAULT_PARAMETERS
+            # 从配置中获取物料默认参数
+            material_default_params = self.workstation.bioyond_config.get("material_default_parameters", {})
+            material_type_params = self.workstation.bioyond_config.get("material_type_parameters", {})
+
+            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
+            merged_params = material_default_params.copy()
+            for type_id, params in material_type_params.items():
+                merged_params[f"type:{type_id}"] = params
 
             bioyond_material = resource_plr_to_bioyond(
                 [resource],
                 type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                 warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=MATERIAL_DEFAULT_PARAMETERS
+                material_params=merged_params
             )[0]
 
             # ⚠️ 关键：创建物料时不设置 locations，让 Bioyond 系统暂不分配库位
@@ -528,8 +623,7 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             logger.info(f"[物料入库] 目标库位: {update_site}")
 
             # 获取仓库配置和目标库位 UUID
-            from .config import WAREHOUSE_MAPPING
-            warehouse_mapping = WAREHOUSE_MAPPING
+            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
 
             parent_name = None
             target_location_uuid = None
@@ -584,6 +678,44 @@ class BioyondWorkstation(WorkstationBase):
     集成Bioyond物料管理的工作站实现
     """
 
+    def _publish_task_status(
+        self,
+        task_id: str,
+        task_type: str,
+        status: str,
+        result: dict = None,
+        progress: float = 0.0,
+        task_code: str = None
+    ):
+        """发布任务状态事件"""
+        try:
+            if not getattr(self, "_ros_node", None):
+                return
+
+            event_data = {
+                "task_id": task_id,
+                "task_code": task_code,
+                "task_type": task_type,
+                "status": status,
+                "progress": progress,
+                "timestamp": datetime.now().isoformat()
+            }
+            if result:
+                event_data["result"] = result
+
+            topic = f"{self._ros_node.namespace}/events/task_status"
+
+            if not hasattr(self, "_task_status_pub"):
+                self._task_status_pub = self._ros_node.create_publisher(
+                    String, topic, 10
+                )
+
+            self._task_status_pub.publish(
+                convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
+            )
+        except Exception as e:
+            logger.error(f"发布任务状态事件失败: {e}")
+
     def __init__(
         self,
         bioyond_config: Optional[Dict[str, Any]] = None,
@@ -605,10 +737,28 @@ class BioyondWorkstation(WorkstationBase):
             raise ValueError("Deck 配置不能为空，请在配置文件中添加正确的 deck 配置")
 
         # 初始化 warehouses 属性
-        self.deck.warehouses = {}
-        for resource in self.deck.children:
-            if isinstance(resource, WareHouse):
-                self.deck.warehouses[resource.name] = resource
+        if not hasattr(self.deck, "warehouses") or self.deck.warehouses is None:
+            self.deck.warehouses = {}
+
+        # 仅当 warehouses 为空时尝试重新扫描（避免覆盖子类的修复）
+        if not self.deck.warehouses:
+            for resource in self.deck.children:
+                # 兼容性增强: 只要是仓库类别或者是 WareHouse 实例均可
+                is_warehouse = isinstance(resource, WareHouse) or getattr(resource, "category", "") == "warehouse"
+
+                # 如果配置中有定义，也可以认定为 warehouse
+                if not is_warehouse and "warehouse_mapping" in bioyond_config:
+                    if resource.name in bioyond_config["warehouse_mapping"]:
+                        is_warehouse = True
+
+                if is_warehouse:
+                    self.deck.warehouses[resource.name] = resource
+                    # 确保 category 被正确设置，方便后续使用
+                    if getattr(resource, "category", "") != "warehouse":
+                        try:
+                            resource.category = "warehouse"
+                        except:
+                            pass
 
         # 创建通信模块
         self._create_communication_module(bioyond_config)
@@ -627,18 +777,22 @@ class BioyondWorkstation(WorkstationBase):
             self._set_workflow_mappings(bioyond_config["workflow_mappings"])
 
         # 准备 HTTP 报送接收服务配置（延迟到 post_init 启动）
-        # 从 bioyond_config 中获取，如果没有则使用 HTTP_SERVICE_CONFIG 的默认值
+        # 从 bioyond_config 中的 http_service_config 获取
+        http_service_cfg = bioyond_config.get("http_service_config", {})
         self._http_service_config = {
-            "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG["http_service_host"]),
-            "port": bioyond_config.get("http_service_port", HTTP_SERVICE_CONFIG["http_service_port"])
+            "host": http_service_cfg.get("http_service_host", "127.0.0.1"),
+            "port": http_service_cfg.get("http_service_port", 8080)
         }
-        self.http_service = None  # 将在 post_init 中启动
+        self.http_service = None  # 将在 post_init 启动
+        self.connection_monitor = None # 将在 post_init 启动
 
         logger.info(f"Bioyond工作站初始化完成")
 
     def __del__(self):
         """析构函数：清理资源，停止 HTTP 服务"""
         try:
+            if hasattr(self, 'connection_monitor') and self.connection_monitor:
+                self.connection_monitor.stop()
             if hasattr(self, 'http_service') and self.http_service is not None:
                 logger.info("正在停止 HTTP 报送服务...")
                 self.http_service.stop()
@@ -648,8 +802,19 @@ class BioyondWorkstation(WorkstationBase):
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
 
+        # 启动连接监控
+        try:
+            self.connection_monitor = ConnectionMonitor(self)
+            self.connection_monitor.start()
+        except Exception as e:
+            logger.error(f"启动连接监控失败: {e}")
+
         # 启动 HTTP 报送接收服务（现在 device_id 已可用）
-        if hasattr(self, '_http_service_config'):
+        # ⚠️ 检查子类是否已经自己管理 HTTP 服务
+        if self.bioyond_config.get("_disable_auto_http_service"):
+            logger.info("🔧 检测到 _disable_auto_http_service 标志，跳过自动启动 HTTP 服务")
+            logger.info("   子类（BioyondCellWorkstation）已自行管理 HTTP 服务")
+        elif hasattr(self, '_http_service_config'):
             try:
                 self.http_service = WorkstationHTTPService(
                     workstation_instance=self,
@@ -688,19 +853,14 @@ class BioyondWorkstation(WorkstationBase):
 
     def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None:
         """创建Bioyond通信模块"""
-        # 创建默认配置
-        default_config = {
-            **API_CONFIG,
-            "workflow_mappings": WORKFLOW_MAPPINGS,
-            "material_type_mappings": MATERIAL_TYPE_MAPPINGS,
-            "warehouse_mapping": WAREHOUSE_MAPPING
-        }
-
-        # 如果传入了 config，合并配置（config 中的值会覆盖默认值）
+        # 直接使用传入的配置，不再使用默认值
+        # 所有配置必须从 JSON 文件中提供
         if config:
-            self.bioyond_config = {**default_config, **config}
+            self.bioyond_config = config
         else:
-            self.bioyond_config = default_config
+            # 如果没有配置，使用空字典（会导致后续错误，但这是预期的）
+            self.bioyond_config = {}
+            print("警告: 未提供 bioyond_config，请确保在 JSON 配置文件中提供完整配置")
 
         self.hardware_interface = BioyondV1RPC(self.bioyond_config)
 
@@ -1014,7 +1174,15 @@ class BioyondWorkstation(WorkstationBase):
 
         workflow_id = self._get_workflow(actual_workflow_name)
         if workflow_id:
-            self.workflow_sequence.append(workflow_id)
+            # 兼容 BioyondReactionStation 中 workflow_sequence 被重写为 property 的情况
+            if isinstance(self.workflow_sequence, list):
+                self.workflow_sequence.append(workflow_id)
+            elif hasattr(self, "_cached_workflow_sequence") and isinstance(self._cached_workflow_sequence, list):
+                self._cached_workflow_sequence.append(workflow_id)
+            else:
+                print(f"❌ 无法添加工作流: workflow_sequence 类型错误 {type(self.workflow_sequence)}")
+                return False
+
             print(f"添加工作流到执行顺序: {actual_workflow_name} -> {workflow_id}")
             return True
         return False
@@ -1215,6 +1383,22 @@ class BioyondWorkstation(WorkstationBase):
             # TODO: 根据实际业务需求处理步骤完成逻辑
             # 例如：更新数据库、触发后续流程等
 
+            # 发布任务状态事件 (running/progress update)
+            self._publish_task_status(
+                task_id=data.get('orderCode'), # 使用 OrderCode 作为关联 ID
+                task_code=data.get('orderCode'),
+                task_type="bioyond_step",
+                status="running",
+                progress=0.5, # 步骤完成视为任务进行中
+                result={"step_name": data.get('stepName'), "step_id": data.get('stepId')}
+            )
+
+            # 更新物料信息
+            # 步骤完成后，物料状态可能发生变化（如位置、用量等），触发同步
+            logger.info(f"[步骤完成报送] 触发物料同步...")
+            self.resource_synchronizer.sync_from_external()
+
+
             return {
                 "processed": True,
                 "step_id": data.get('stepId'),
@@ -1249,6 +1433,17 @@ class BioyondWorkstation(WorkstationBase):
 
             # TODO: 根据实际业务需求处理通量完成逻辑
 
+            # 发布任务状态事件
+            self._publish_task_status(
+                task_id=data.get('orderCode'),
+                task_code=data.get('orderCode'),
+                task_type="bioyond_sample",
+                status="running",
+                progress=0.7,
+                result={"sample_id": data.get('sampleId'), "status": status_desc}
+            )
+
+
             return {
                 "processed": True,
                 "sample_id": data.get('sampleId'),
@@ -1288,6 +1483,32 @@ class BioyondWorkstation(WorkstationBase):
             # TODO: 根据实际业务需求处理任务完成逻辑
             # 例如：更新物料库存、生成报表等
 
+            # 映射状态到事件状态
+            event_status = "completed"
+            if str(data.get('status')) in ["-11", "-12"]:
+                event_status = "error"
+            elif str(data.get('status')) == "30":
+                event_status = "completed"
+            else:
+                event_status = "running" # 其他状态视为运行中（或根据实际定义）
+
+            # 发布任务状态事件
+            self._publish_task_status(
+                task_id=data.get('orderCode'),
+                task_code=data.get('orderCode'),
+                task_type="bioyond_order",
+                status=event_status,
+                progress=1.0 if event_status in ["completed", "error"] else 0.9,
+                result={"order_name": data.get('orderName'), "status": status_desc, "materials_count": len(used_materials)}
+            )
+
+            # 更新物料信息
+            # 任务完成后，且状态为完成时，触发同步以更新最终物料状态
+            if event_status == "completed":
+                logger.info(f"[任务完成报送] 触发物料同步...")
+                self.resource_synchronizer.sync_from_external()
+
+
             return {
                 "processed": True,
                 "order_code": data.get('orderCode'),

unilabos/devices/workstation/coin_cell_assembly/20251230_Modbus_CSV_Mapping_Guide.md

@@ -0,0 +1,84 @@
+# Modbus CSV 地址映射说明
+
+本文档说明 `coin_cell_assembly_a.csv` 文件如何将命名节点映射到实际的 Modbus 地址，以及如何在代码中使用它们。
+
+## 1. CSV 文件结构
+
+地址表文件位于同级目录下：`coin_cell_assembly_a.csv`
+
+每一行定义了一个 Modbus 节点，包含以下关键列：
+
+| 列名 | 说明 | 示例 |
+|------|------|------|
+| **Name** | **节点名称** (代码中引用的 Key) | `COIL_ALUMINUM_FOIL` |
+| **DataType** | 数据类型 (BOOL, INT16, FLOAT32, STRING) | `BOOL` |
+| **Comment** | 注释说明 | `使用铝箔垫` |
+| **Attribute** | 属性 (通常留空或用于额外标记) | |
+| **DeviceType** | Modbus 寄存器类型 (`coil`, `hold_register`) | `coil` |
+| **Address** | **Modbus 地址** (十进制) | `8340` |
+
+### 示例行 (铝箔垫片)
+
+```csv
+COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,8340,
+```
+
+- **名称**: `COIL_ALUMINUM_FOIL`
+- **类型**: `coil` (线圈，读写单个位)
+- **地址**: `8340`
+
+---
+
+## 2. 加载与注册流程
+
+在 `coin_cell_assembly.py` 的初始化代码中：
+
+1. **加载 CSV**: `BaseClient.load_csv()` 读取 CSV 并解析每行定义。
+2. **注册节点**: `modbus_client.register_node_list()` 将解析后的节点注册到 Modbus 客户端实例中。
+
+```python
+# 代码位置: coin_cell_assembly.py (L174-175)
+self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_a.csv'))                            
+self.client = modbus_client.register_node_list(self.nodes)
+```
+
+---
+
+## 3. 代码中的使用方式
+
+注册后，通过 `self.client.use_node('节点名称')` 即可获取该节点对象并进行读写操作，无需关心具体地址。
+
+### 控制铝箔垫片 (COIL_ALUMINUM_FOIL)
+
+```python
+# 代码位置: qiming_coin_cell_code 函数 (L1048)
+self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian)
+```
+
+- **写入 True**: 对应 Modbus 功能码 05 (Write Single Coil)，向地址 `8340` 写入 `1` (ON)。
+- **写入 False**: 向地址 `8340` 写入 `0` (OFF)。
+
+> **注意**: 代码中使用了 `not lvbodian`，这意味着逻辑是反转的。如果 `lvbodian` 参数为 `True` (默认)，写入的是 `False` (不使用铝箔垫)。
+
+---
+
+## 4. 地址转换注意事项 (Modbus vs PLC)
+
+CSV 中的 `Address` 列（如 `8340`）是 **Modbus 协议地址**。
+
+如果使用 InoProShop (汇川 PLC 编程软件)，看到的可能是 **PLC 内部地址** (如 `%QX...` 或 `%MW...`)。这两者之间通常需要转换。
+
+### 常见的转换规则 (示例)
+
+- **Coil (线圈) %QX**: 
+  - `Modbus地址 = 字节地址 * 8 + 位偏移`
+  - *例子*: `%QX834.0` -> `834 * 8 + 0` = `6672`
+  - *注意*: 如果 CSV 中配置的是 `8340`，这可能是一个自定义映射，或者是基于不同规则（如直接对应 Word 地址的某种映射，或者可能就是地址写错了/使用了非标准映射）。
+
+- **Register (寄存器) %MW**:
+  - 通常直接对应，或者有偏移量 (如 Modbus 40001 = PLC MW0)。
+
+### 验证方法
+由于 `test_unilab_interact.py` 中发现 `8450` (CSV风格) 不工作，而 `6760` (%QX845.0 计算值) 工作正常，**建议对 CSV 中的其他地址也进行核实**，特别是像 `8340` 这样以 0 结尾看起来像是 "字节地址+0" 的数值，可能实际上应该是 `%QX834.0` 对应的 `6672`。
+
+如果发现设备控制无反应，请尝试按照标准的 Modbus 计算方式转换 PLC 地址。

unilabos/devices/workstation/coin_cell_assembly/20260113_物料搜寻确认弹窗自动处理功能.md

@@ -0,0 +1,352 @@
+# 2026-01-13 物料搜寻确认弹窗自动处理功能
+
+## 概述
+
+本次更新为设备初始化流程添加了**物料搜寻确认弹窗自动检测与处理功能**。在设备初始化过程中，PLC 会弹出物料搜寻确认对话框，现在系统可以根据用户参数自动点击"是"或"否"按钮，无需手动干预。
+
+## 背景问题
+
+### 原有流程
+1. 调用 `func_pack_device_init_auto_start_combined()` 初始化设备
+2. PLC 在初始化过程中弹出物料搜寻确认对话框
+3. **需要人工手动点击**"是"或"否"按钮
+4. PLC 继续完成初始化并启动
+
+### 存在的问题
+- 需要人工干预，无法实现全自动化
+- 影响批量生产效率
+- 容易遗忘点击导致流程卡住
+
+## 解决方案
+
+### 新增 Modbus 地址配置
+
+在 `coin_cell_assembly_b.csv` 第 69-71 行添加三个 coil：
+
+| Name | DeviceType | Address | 说明 |
+|------|-----------|---------|------|
+| COIL_MATERIAL_SEARCH_DIALOG_APPEAR | coil | 6470 | 物料搜寻确认弹窗画面是否出现 |
+| COIL_MATERIAL_SEARCH_CONFIRM_YES | coil | 6480 | 初始化物料搜寻确认按钮"是" |
+| COIL_MATERIAL_SEARCH_CONFIRM_NO | coil | 6490 | 初始化物料搜寻确认按钮"否" |
+
+**Modbus 地址转换：**
+- CSV 6470 → Modbus 5176 (弹窗出现)
+- CSV 6480 → Modbus 5184 (按钮"是")
+- CSV 6490 → Modbus 5192 (按钮"否")
+
+## 代码修改详情
+
+### 1. coin_cell_assembly.py
+
+#### 1.1 新增辅助方法 `_handle_material_search_dialog()`
+
+**位置：** 第 799-901 行
+
+**功能：**
+- 监测物料搜寻确认弹窗是否出现（Coil 5176）
+- 根据 `enable_search` 参数自动点击对应按钮
+- 使用**脉冲模式**模拟真实按钮操作：`True` → 保持 0.5 秒 → `False`
+
+**参数：**
+- `enable_search: bool` - True=点击"是"(启用物料搜寻), False=点击"否"(不启用)
+- `timeout: int = 30` - 等待弹窗出现的最大时间（秒）
+
+**逻辑流程：**
+```python
+1. 监测 COIL_MATERIAL_SEARCH_DIALOG_APPEAR (每 0.5 秒检查一次)
+2. 检测到弹窗出现 (Coil = True)
+3. 选择按钮：
+   - enable_search=True  → COIL_MATERIAL_SEARCH_CONFIRM_YES
+   - enable_search=False → COIL_MATERIAL_SEARCH_CONFIRM_NO
+4. 执行脉冲操作：
+   - 写入 True (按下按钮)
+   - 等待 0.5 秒
+   - 写入 False (释放按钮)
+   - 验证状态
+```
+
+#### 1.2 修改 `func_pack_device_init_auto_start_combined()`
+
+**位置：** 第 904-1115 行
+
+**主要改动：**
+
+1. **添加新参数**
+   ```python
+   def func_pack_device_init_auto_start_combined(
+       self, 
+       material_search_enable: bool = False  # 新增参数
+   ) -> bool:
+   ```
+
+2. **内联初始化逻辑并集成弹窗检测**
+   - 不再调用 `self.func_pack_device_init()`
+   - 将初始化逻辑直接实现在函数内
+   - **在等待初始化完成的循环中实时检测弹窗**
+   - 避免死锁：PLC 等待弹窗确认 ↔ 代码等待初始化完成
+
+3. **关键代码片段**
+   ```python
+   # 等待初始化完成，同时检测物料搜寻弹窗
+   while (self._sys_init_status()) == False:
+       # 检查超时
+       if time.time() - start_wait > max_wait_time:
+           raise RuntimeError(f"初始化超时")
+       
+       # 如果还没处理弹窗，检测弹窗是否出现
+       if not dialog_handled:
+           dialog_state = self.client.use_node('COIL_MATERIAL_SEARCH_DIALOG_APPEAR').read(1)
+           if dialog_actual:  # 弹窗出现
+               # 执行脉冲按钮点击
+               button_node.write(True)   # 按下
+               time.sleep(0.5)            # 保持
+               button_node.write(False)   # 释放
+               dialog_handled = True
+       
+       time.sleep(1)
+   ```
+
+4. **步骤调整**
+   - 步骤 0: 前置条件检查
+   - 步骤 1: 设备初始化（**包含弹窗检测**）
+   - 步骤 1.5: 已在步骤 1 中完成
+   - 步骤 2: 切换自动模式
+   - 步骤 3: 启动设备
+
+### 2. coin_cell_workstation.yaml
+
+**位置：** 第 292-312 行
+
+**修改内容：**
+
+```yaml
+auto-func_pack_device_init_auto_start_combined:
+  goal_default:
+    material_search_enable: false  # 新增默认值
+  
+  schema:
+    description: 组合函数:设备初始化 + 物料搜寻确认 + 切换自动模式 + 启动。初始化过程中会自动检测物料搜寻确认弹窗，并根据参数自动点击"是"或"否"按钮
+    
+    goal:
+      properties:
+        material_search_enable:  # 新增参数配置
+          default: false
+          description: 是否启用物料搜寻功能。设备初始化后会弹出物料搜寻确认弹窗，此参数控制自动点击"是"(启用)或"否"(不启用)。默认为false(不启用物料搜寻)
+          type: boolean
+```
+
+### 3. 测试脚本（已创建，用户已删除）
+
+#### 3.1 test_material_search_dialog.py
+- 从 CSV 动态加载 Modbus 地址
+- 支持 4 种测试模式：
+  - `query` - 查询所有状态
+  - `dialog <0|1>` - 设置弹窗出现/消失
+  - `yes` - 脉冲点击"是"按钮
+  - `no` - 脉冲点击"否"按钮
+- 兼容 pymodbus 3.x API
+
+#### 3.2 更新其他测试脚本
+- `test_coin_cell_reset.py` - 更新为 pymodbus 3.x API
+- `test_unilab_interact.py` - 更新为 pymodbus 3.x API
+
+## 使用方法
+
+### 参数说明
+
+| 参数 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `material_search_enable` | boolean | `false` | 是否启用物料搜寻功能 |
+
+### 调用示例
+
+#### 1. 不启用物料搜寻（默认）
+```python
+# 默认参数，点击"否"按钮
+await device.func_pack_device_init_auto_start_combined()
+```
+
+或在 YAML workflow 中：
+```yaml
+# 使用默认值 false，不启用物料搜寻
+- BatteryStation/auto-func_pack_device_init_auto_start_combined: {}
+```
+
+#### 2. 启用物料搜寻
+```python
+# 显式设置为 True，点击"是"按钮
+await device.func_pack_device_init_auto_start_combined(
+    material_search_enable=True
+)
+```
+
+或在 YAML workflow 中：
+```yaml
+- BatteryStation/auto-func_pack_device_init_auto_start_combined:
+    goal:
+      material_search_enable: true  # 启用物料搜寻
+```
+
+## 执行日志示例
+
+```
+26-01-13 [21:32:44] [INFO] 开始组合操作：设备初始化 → 物料搜寻确认 → 自动模式 → 启动
+26-01-13 [21:32:44] [INFO] 【步骤 0/4】前置条件检查...
+26-01-13 [21:32:44] [INFO]   ✓ REG_UNILAB_INTERACT 检查通过
+26-01-13 [21:32:44] [INFO]   ✓ COIL_GB_L_IGNORE_CMD 检查通过
+26-01-13 [21:32:44] [INFO] 【步骤 1/4】设备初始化...
+26-01-13 [21:32:44] [INFO] 切换手动模式...
+26-01-13 [21:32:46] [INFO] 发送初始化命令...
+26-01-13 [21:32:47] [INFO] 等待初始化完成（同时监测物料搜寻弹窗）...
+26-01-13 [21:33:05] [INFO] ✓ 在初始化过程中检测到物料搜寻确认弹窗！
+26-01-13 [21:33:05] [INFO] 用户选择: 不启用物料搜寻（点击否）
+26-01-13 [21:33:05] [INFO]   → 按下按钮 '否'
+26-01-13 [21:33:06] [INFO]   → 释放按钮 '否'
+26-01-13 [21:33:07] [INFO] ✓ 成功处理物料搜寻确认弹窗（选择: 否）
+26-01-13 [21:33:08] [INFO] ✓ 初始化状态完成
+26-01-13 [21:33:12] [INFO] ✓ 设备初始化完成
+26-01-13 [21:33:12] [INFO] 【步骤 1.5/4】物料搜寻确认已在初始化过程中完成
+26-01-13 [21:33:12] [INFO] 【步骤 2/4】切换自动模式...
+26-01-13 [21:33:15] [INFO] ✓ 切换自动模式完成
+26-01-13 [21:33:15] [INFO] 【步骤 3/4】启动设备...
+26-01-13 [21:33:18] [INFO] ✓ 启动设备完成
+26-01-13 [21:33:18] [INFO] 组合操作完成：设备已成功初始化、确认物料搜寻、切换自动模式并启动
+```
+
+## 技术要点
+
+### 1. 脉冲模式按钮操作
+模拟真实按钮按压过程：
+1. 写入 `True` (按下)
+2. 保持 0.5 秒
+3. 写入 `False` (释放)
+4. 验证状态
+
+### 2. 避免死锁
+**问题：** PLC 在初始化过程中等待弹窗确认，而代码等待初始化完成  
+**解决：** 在初始化等待循环中实时检测弹窗，一旦出现立即处理
+
+### 3. 超时保护
+- 弹窗检测超时：30 秒（在 `_handle_material_search_dialog` 中）
+- 初始化超时：120 秒（在 `func_pack_device_init_auto_start_combined` 中）
+
+### 4. PyModbus 3.x API 兼容
+所有 Modbus 操作使用 keyword arguments：
+```python
+# 读取
+client.read_coils(address=5176, count=1)
+
+# 写入
+client.write_coil(address=5184, value=True)
+```
+
+## 向后兼容性
+
+### 保留的原有函数
+- `func_pack_device_init()` - 单独的初始化函数，不包含弹窗处理
+- 仍可在 YAML 中通过 `auto-func_pack_device_init` 调用
+- 用于不需要自动处理弹窗的场景
+
+### 新增的功能
+- 在 `func_pack_device_init_auto_start_combined()` 中集成弹窗处理
+- 通过参数控制，默认行为与之前兼容（点击"否"）
+
+## 验证测试
+
+### 测试场景
+
+#### 场景 1：默认参数（不启用物料搜寻）
+```bash
+# 调用时不传参数
+BatteryStation/auto-func_pack_device_init_auto_start_combined: {}
+```
+**预期结果：**
+- ✅ 检测到弹窗
+- ✅ 自动点击"否"按钮
+- ✅ 初始化完成并启动成功
+
+#### 场景 2：启用物料搜寻
+```bash
+# 设置 material_search_enable=true
+BatteryStation/auto-func_pack_device_init_auto_start_combined:
+  goal:
+    material_search_enable: true
+```
+**预期结果：**
+- ✅ 检测到弹窗
+- ✅ 自动点击"是"按钮
+- ✅ 初始化完成并启动成功
+
+### 实际测试结果
+
+**测试时间：** 2026-01-13 21:32:43  
+**测试参数：** `material_search_enable: false`  
+**测试结果：** ✅ 成功
+
+**关键时间节点：**
+- 21:33:05 - 检测到弹窗
+- 21:33:05 - 按下"否"按钮
+- 21:33:06 - 释放"否"按钮  
+- 21:33:07 - 弹窗处理完成
+- 21:33:08 - 初始化状态完成
+- 21:33:18 - 整个流程完成
+
+**总耗时：** 约 35 秒（包含初始化全过程）
+
+## 注意事项
+
+1. **CSV 配置依赖**
+   - 确保 `coin_cell_assembly_b.csv` 包含 69-71 行的 coil 配置
+   - 地址转换逻辑：`modbus_addr = (csv_addr // 10) * 8 + (csv_addr % 10)`
+
+2. **默认行为**
+   - 默认 `material_search_enable=false`，即不启用物料搜寻
+   - 如需启用，必须显式设置为 `true`
+
+3. **日志级别**
+   - 弹窗检测过程中的 `waiting for init_cmd` 使用 DEBUG 级别
+   - 关键操作（检测到弹窗、按钮操作）使用 INFO 级别
+
+4. **原有函数保留**
+   - `func_pack_device_init()` 仍然可用，但不包含弹窗处理
+   - 如果单独调用此函数，仍需手动处理弹窗
+
+## 文件清单
+
+### 修改的文件
+1. `d:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly.py`
+   - 新增 `_handle_material_search_dialog()` 方法
+   - 修改 `func_pack_device_init_auto_start_combined()` 函数
+
+2. `d:\UniLabdev\Uni-Lab-OS\unilabos\registry\devices\coin_cell_workstation.yaml`
+   - 更新 `auto-func_pack_device_init_auto_start_combined` 配置
+   - 添加 `material_search_enable` 参数说明
+
+3. `d:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly_b.csv`
+   - 第 69-71 行添加三个 coil 配置
+
+### 创建的测试文件（已删除）
+1. `test_material_search_dialog.py` - 物料搜寻弹窗测试脚本
+2. `test_coin_cell_reset.py` - 复位功能测试（更新为 pymodbus 3.x）
+3. `test_unilab_interact.py` - Unilab 交互测试（更新为 pymodbus 3.x）
+
+## 总结
+
+本次更新成功实现了设备初始化过程中物料搜寻确认弹窗的自动化处理，主要优势：
+
+✅ **全自动化** - 无需人工干预  
+✅ **参数可配** - 灵活控制是否启用物料搜寻  
+✅ **实时检测** - 在初始化等待循环中检测，避免死锁  
+✅ **脉冲模式** - 模拟真实按钮操作  
+✅ **向后兼容** - 保留原有函数，不影响现有流程  
+✅ **完整日志** - 详细记录每一步操作  
+✅ **超时保护** - 防止无限等待  
+
+该功能已通过实际测试验证，可投入生产使用。
+
+---
+
+**文档版本：** 1.0  
+**创建日期：** 2026-01-13  
+**作者：** Antigravity AI Assistant  
+**最后更新：** 2026-01-13 21:36

unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py

@@ -0,0 +1,645 @@
+"""
+纽扣电池组装工作站物料类定义
+Button Battery Assembly Station Resource Classes
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, TypedDict, Union, cast
+
+from pylabrobot.resources.coordinate import Coordinate
+from pylabrobot.resources.container import Container
+from pylabrobot.resources.deck import Deck
+from pylabrobot.resources.itemized_resource import ItemizedResource
+from pylabrobot.resources.resource import Resource
+from pylabrobot.resources.resource_stack import ResourceStack
+from pylabrobot.resources.tip_rack import TipRack, TipSpot
+from pylabrobot.resources.trash import Trash
+from pylabrobot.resources.utils import create_ordered_items_2d
+
+from unilabos.resources.battery.magazine import MagazineHolder_4_Cathode, MagazineHolder_6_Cathode, MagazineHolder_6_Anode, MagazineHolder_6_Battery
+from unilabos.resources.battery.bottle_carriers import YIHUA_Electrolyte_12VialCarrier
+from unilabos.resources.battery.electrode_sheet import ElectrodeSheet
+
+
+
+# TODO: 这个应该只能放一个极片
+class MaterialHoleState(TypedDict):
+    diameter: int
+    depth: int
+    max_sheets: int
+    info: Optional[str]  # 附加信息
+
+class MaterialHole(Resource):
+    """料板洞位类"""
+    children: List[ElectrodeSheet] = []
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        category: str = "material_hole",
+        **kwargs
+    ):
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+        )
+        self._unilabos_state: MaterialHoleState = MaterialHoleState(
+            diameter=20,
+            depth=10,
+            max_sheets=1,
+            info=None
+        )
+
+    def get_all_sheet_info(self):
+        info_list = []
+        for sheet in self.children:
+            info_list.append(sheet._unilabos_state["info"])
+        return info_list
+    
+    #这个函数函数好像没用，一般不会集中赋值质量
+    def set_all_sheet_mass(self):
+        for sheet in self.children:
+            sheet._unilabos_state["mass"] = 0.5  # 示例：设置质量为0.5g
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+    #移动极片前先取出对象
+    def get_sheet_with_name(self, name: str) -> Optional[ElectrodeSheet]:
+        for sheet in self.children:
+            if sheet.name == name:
+                return sheet
+        return None
+
+    def has_electrode_sheet(self) -> bool:
+        """检查洞位是否有极片"""
+        return len(self.children) > 0
+
+    def assign_child_resource(
+        self,
+        resource: ElectrodeSheet,
+        location: Optional[Coordinate],
+        reassign: bool = True,
+    ):
+        """放置极片"""
+        # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题
+        #if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]:
+        #    raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}")
+        #if len(self.children) >= self._unilabos_state["max_sheets"]:
+        #    raise ValueError(f"洞位已满，无法放置更多极片")
+        super().assign_child_resource(resource, location, reassign)
+
+    # 根据children的编号取物料对象。
+    def get_electrode_sheet_info(self, index: int) -> ElectrodeSheet:
+        return self.children[index]
+
+
+class MaterialPlateState(TypedDict):
+    hole_spacing_x: float
+    hole_spacing_y: float
+    hole_diameter: float
+    info: Optional[str]  # 附加信息
+
+class MaterialPlate(ItemizedResource[MaterialHole]):
+    """料板类 - 4x4个洞位，每个洞位放1个极片"""
+    
+    children: List[MaterialHole]
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        ordered_items: Optional[Dict[str, MaterialHole]] = None,
+        ordering: Optional[OrderedDict[str, str]] = None,
+        category: str = "material_plate",
+        model: Optional[str] = None,
+        fill: bool = False
+    ):
+        """初始化料板
+
+        Args:
+            name: 料板名称
+            size_x: 长度 (mm)
+            size_y: 宽度 (mm)
+            size_z: 高度 (mm)
+            hole_diameter: 洞直径 (mm)
+            hole_depth: 洞深度 (mm)
+            hole_spacing_x: X方向洞位间距 (mm)
+            hole_spacing_y: Y方向洞位间距 (mm)
+            number: 编号
+            category: 类别
+            model: 型号
+        """
+        self._unilabos_state: MaterialPlateState = MaterialPlateState(
+            hole_spacing_x=24.0,
+            hole_spacing_y=24.0,
+            hole_diameter=20.0,
+            info="",
+        )
+        # 创建4x4的洞位
+        # TODO: 这里要改，对应不同形状
+        holes = create_ordered_items_2d(
+            klass=MaterialHole,
+            num_items_x=4,
+            num_items_y=4,
+            dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
+            dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
+            dz=size_z,
+            item_dx=self._unilabos_state["hole_spacing_x"],
+            item_dy=self._unilabos_state["hole_spacing_y"],
+            size_x = 16,
+            size_y = 16,
+            size_z = 16,
+        )
+        if fill:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=holes,
+                category=category,
+                model=model,
+            )
+        else:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=ordered_items,
+                ordering=ordering,
+                category=category,
+                model=model,
+            )
+
+    def update_locations(self):
+        # TODO:调多次相加
+        holes = create_ordered_items_2d(
+            klass=MaterialHole,
+            num_items_x=4,
+            num_items_y=4,
+            dx=(self._size_x - 3 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
+            dy=(self._size_y - 3 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
+            dz=self._size_z,
+            item_dx=self._unilabos_state["hole_spacing_x"],
+            item_dy=self._unilabos_state["hole_spacing_y"],
+            size_x = 1,
+            size_y = 1,
+            size_z = 1,
+        )
+        for item, original_item in zip(holes.items(), self.children):
+            original_item.location = item[1].location
+
+
+class PlateSlot(ResourceStack):
+    """板槽位类 - 1个槽上能堆放8个板，移板只能操作最上方的板"""
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        max_plates: int = 8,
+        category: str = "plate_slot",
+        model: Optional[str] = None
+    ):
+        """初始化板槽位
+
+        Args:
+            name: 槽位名称
+            max_plates: 最大板数量
+            category: 类别
+        """
+        super().__init__(
+            name=name,
+            direction="z",  # Z方向堆叠
+            resources=[],
+        )
+        self.max_plates = max_plates
+        self.category = category
+
+    def can_add_plate(self) -> bool:
+        """检查是否可以添加板"""
+        return len(self.children) < self.max_plates
+
+    def add_plate(self, plate: MaterialPlate) -> None:
+        """添加料板"""
+        if not self.can_add_plate():
+            raise ValueError(f"槽位 {self.name} 已满，无法添加更多板")
+        self.assign_child_resource(plate)
+
+    def get_top_plate(self) -> MaterialPlate:
+        """获取最上方的板"""
+        if len(self.children) == 0:
+            raise ValueError(f"槽位 {self.name} 为空")
+        return cast(MaterialPlate, self.get_top_item())
+
+    def take_top_plate(self) -> MaterialPlate:
+        """取出最上方的板"""
+        top_plate = self.get_top_plate()
+        self.unassign_child_resource(top_plate)
+        return top_plate
+
+    def can_access_for_picking(self) -> bool:
+        """检查是否可以进行取料操作（只有最上方的板能进行取料操作）"""
+        return len(self.children) > 0
+
+    def serialize(self) -> dict:
+        return {
+            **super().serialize(),
+            "max_plates": self.max_plates,
+        }
+
+
+#是一种类型注解，不用self
+class BatteryState(TypedDict):
+    """电池状态字典"""
+    diameter: float
+    height: float
+    assembly_pressure: float
+    electrolyte_volume: float
+    electrolyte_name: str
+
+class Battery(Resource):
+    """电池类 - 可容纳极片"""
+    children: List[ElectrodeSheet] = []
+
+    def __init__(
+        self,
+        name: str,
+        size_x=1,
+        size_y=1,
+        size_z=1,
+        category: str = "battery",
+    ):
+        """初始化电池
+
+        Args:
+            name: 电池名称
+            diameter: 直径 (mm)
+            height: 高度 (mm)
+            max_volume: 最大容量 (μL)
+            barcode: 二维码编号
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=1,
+            size_y=1,
+            size_z=1,
+            category=category,
+        )
+        self._unilabos_state: BatteryState = BatteryState(
+                                 diameter = 1.0,
+                                 height = 1.0,
+                                 assembly_pressure = 1.0,
+                                 electrolyte_volume = 1.0,
+                                 electrolyte_name = "DP001"
+                                 )
+
+    def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool:
+        to_add_name = bottle._unilabos_state["electrolyte_name"]
+        if bottle.aspirate_electrolyte(10):
+            if self.add_electrolyte(to_add_name, 10):
+                pass
+            else:
+                bottle._unilabos_state["electrolyte_volume"] += 10
+
+    def set_electrolyte(self, name: str, volume: float) -> None:
+        """设置电解液信息"""
+        self._unilabos_state["electrolyte_name"] = name
+        self._unilabos_state["electrolyte_volume"] = volume
+    #这个应该没用，不会有加了后再加的事情
+    def add_electrolyte(self, name: str, volume: float) -> bool:
+        """添加电解液信息"""
+        if name != self._unilabos_state["electrolyte_name"]:
+            return False
+        self._unilabos_state["electrolyte_volume"] += volume
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+# 电解液作为属性放进去
+
+class BatteryPressSlotState(TypedDict):
+    """电池状态字典"""
+    diameter: float =20.0
+    depth: float = 4.0
+
+class BatteryPressSlot(Resource):
+    """电池压制槽类 - 设备，可容纳一个电池"""
+    children: List[Battery] = []
+
+    def __init__(
+        self,
+        name: str = "BatteryPressSlot",
+        category: str = "battery_press_slot",
+    ):
+        """初始化电池压制槽
+
+        Args:
+            name: 压制槽名称
+            diameter: 直径 (mm)
+            depth: 深度 (mm)
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=10,
+            size_y=12,
+            size_z=13,
+            category=category,
+        )
+        self._unilabos_state: BatteryPressSlotState = BatteryPressSlotState()
+
+    def has_battery(self) -> bool:
+        """检查是否有电池"""
+        return len(self.children) > 0
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+    
+    def assign_child_resource(
+        self,
+        resource: Battery,
+        location: Optional[Coordinate],
+        reassign: bool = True,
+    ):
+        """放置极片"""
+        # TODO: 让高京看下槽位只有一个电池时是否这么写。
+        if self.has_battery():
+            raise ValueError(f"槽位已含有一个电池，无法再放置其他电池")
+        super().assign_child_resource(resource, location, reassign)
+
+    # 根据children的编号取物料对象。
+    def get_battery_info(self, index: int) -> Battery:
+        return self.children[0]
+
+
+def TipBox64(
+        name: str,
+        size_x: float = 127.8,
+        size_y: float = 85.5,
+        size_z: float = 60.0,
+        category: str = "tip_rack",
+        model: Optional[str] = None,
+):
+    """64孔枪头盒类"""
+    from pylabrobot.resources.tip import Tip
+
+    # 创建12x8=96个枪头位
+    def make_tip():
+        return Tip(
+            has_filter=False,
+            total_tip_length=20.0,
+            maximal_volume=1000,  # 1mL
+            fitting_depth=8.0,
+        )
+
+    tip_spots = create_ordered_items_2d(
+        klass=TipSpot,
+        num_items_x=12,
+        num_items_y=8,
+        dx=8.0,
+        dy=8.0,
+        dz=0.0,
+        item_dx=9.0,
+        item_dy=9.0,
+        size_x=10,
+        size_y=10,
+        size_z=0.0,
+        make_tip=make_tip,
+    )
+    idx_available = list(range(0, 32)) + list(range(64, 96))
+    tip_spots_available = {k: v for i, (k, v) in enumerate(tip_spots.items()) if i in idx_available}
+    tip_rack = TipRack(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        # ordered_items=tip_spots_available,
+        ordered_items=tip_spots,
+        category=category,
+        model=model,
+        with_tips=False,
+    )
+    tip_rack.set_tip_state([True]*32 + [False]*32 + [True]*32)  # 前32和后32个有枪头，中间32个无枪头
+    return tip_rack
+
+
+class WasteTipBoxstate(TypedDict):
+    """"废枪头盒状态字典"""
+    max_tips: int = 100
+    tip_count: int = 0
+
+#枪头不是一次性的（同一溶液则反复使用），根据寄存器判断
+class WasteTipBox(Trash):
+    """废枪头盒类 - 100个枪头容量"""
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float = 127.8,
+        size_y: float = 85.5,
+        size_z: float = 60.0,
+        material_z_thickness=0,
+        max_volume=float("inf"),
+        category="trash",
+        model=None,
+        compute_volume_from_height=None,
+        compute_height_from_volume=None,
+    ):
+        """初始化废枪头盒
+
+        Args:
+            name: 废枪头盒名称
+            size_x: 长度 (mm)
+            size_y: 宽度 (mm)
+            size_z: 高度 (mm)
+            max_tips: 最大枪头容量
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+            model=model,
+        )
+        self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate()
+
+    def add_tip(self) -> None:
+        """添加废枪头"""
+        if self._unilabos_state["tip_count"] >= self._unilabos_state["max_tips"]:
+            raise ValueError(f"废枪头盒 {self.name} 已满")
+        self._unilabos_state["tip_count"] += 1
+
+    def get_tip_count(self) -> int:
+        """获取枪头数量"""
+        return self._unilabos_state["tip_count"]
+
+    def empty(self) -> None:
+        """清空废枪头盒"""
+        self._unilabos_state["tip_count"] = 0
+
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+
+class CoincellDeck(Deck):
+    """纽扣电池组装工作站台面类"""
+
+    def __init__(
+        self,
+        name: str = "coin_cell_deck",
+        size_x: float = 1450.0,  # 1m
+        size_y: float = 1450.0,  # 1m
+        size_z: float = 100.0,   # 0.9m
+        origin: Coordinate = Coordinate(-2200, 0, 0),
+        category: str = "coin_cell_deck",
+        setup: bool = False,  # 是否自动执行 setup
+    ):
+        """初始化纽扣电池组装工作站台面
+
+        Args:
+            name: 台面名称
+            size_x: 长度 (mm) - 1m
+            size_y: 宽度 (mm) - 1m
+            size_z: 高度 (mm) - 0.9m
+            origin: 原点坐标
+            category: 类别
+            setup: 是否自动执行 setup 配置标准布局
+        """
+        super().__init__(
+            name=name,
+            size_x=1450.0,
+            size_y=1450.0,
+            size_z=100.0,
+            origin=origin,
+        )
+        if setup:
+            self.setup()
+
+    def setup(self) -> None:
+        """设置工作站的标准布局 - 包含子弹夹、料盘、瓶架等完整配置"""
+        # ====================================== 子弹夹 ============================================
+        
+        # 正极片（4个洞位，2x2布局）
+        zhengji_zip = MagazineHolder_4_Cathode("正极&铝箔弹夹")
+        self.assign_child_resource(zhengji_zip, Coordinate(x=402.0, y=830.0, z=0))
+        
+        # 正极壳、平垫片（6个洞位，2x2+2布局）
+        zhengjike_zip = MagazineHolder_6_Cathode("正极壳&平垫片弹夹")
+        self.assign_child_resource(zhengjike_zip, Coordinate(x=566.0, y=272.0, z=0))
+        
+        # 负极壳、弹垫片（6个洞位，2x2+2布局）
+        fujike_zip = MagazineHolder_6_Anode("负极壳&弹垫片弹夹")
+        self.assign_child_resource(fujike_zip, Coordinate(x=474.0, y=276.0, z=0))
+        
+        # 成品弹夹（6个洞位，3x2布局）
+        chengpindanjia_zip = MagazineHolder_6_Battery("成品弹夹")
+        self.assign_child_resource(chengpindanjia_zip, Coordinate(x=260.0, y=156.0, z=0))
+        
+        # ====================================== 物料板 ============================================
+        # 创建物料板（料盘carrier）- 4x4布局
+        # 负极料盘
+        fujiliaopan = MaterialPlate(name="负极料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
+        self.assign_child_resource(fujiliaopan, Coordinate(x=708.0, y=794.0, z=0))
+        # for i in range(16):
+        #     fujipian = ElectrodeSheet(name=f"{fujiliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
+        #     fujiliaopan.children[i].assign_child_resource(fujipian, location=None)
+
+        # 隔膜料盘
+        gemoliaopan = MaterialPlate(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
+        self.assign_child_resource(gemoliaopan, Coordinate(x=718.0, y=918.0, z=0))
+        # for i in range(16):
+        #     gemopian = ElectrodeSheet(name=f"{gemoliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
+        #     gemoliaopan.children[i].assign_child_resource(gemopian, location=None)
+
+        # ====================================== 瓶架、移液枪 ============================================
+        # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒
+        # 奔耀上料5ml分液瓶小板 - 由奔曜跨站转运而来，不单独写，但是这里应该有一个堆栈用于摆放分液瓶小板
+        
+        # bottle_rack_3x4 = BottleRack(
+        #     name="bottle_rack_3x4",
+        #     size_x=210.0,
+        #     size_y=140.0,
+        #     size_z=100.0,
+        #     num_items_x=2,
+        #     num_items_y=4,
+        #     position_spacing=35.0,
+        #     orientation="vertical",
+        # )
+        # self.assign_child_resource(bottle_rack_3x4, Coordinate(x=1542.0, y=717.0, z=0))
+        
+        # 电解液缓存位 - 6x2布局
+        bottle_rack_6x2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2")
+        self.assign_child_resource(bottle_rack_6x2, Coordinate(x=1050.0, y=358.0, z=0))
+        # 电解液回收位6x2
+        bottle_rack_6x2_2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2_2")
+        self.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=914.0, y=358.0, z=0))
+
+        tip_box = TipBox64(name="tip_box_64")
+        self.assign_child_resource(tip_box, Coordinate(x=782.0, y=514.0, z=0))
+
+        waste_tip_box = WasteTipBox(name="waste_tip_box")
+        self.assign_child_resource(waste_tip_box, Coordinate(x=778.0, y=622.0, z=0))
+
+
+def YH_Deck(name=""):
+    cd = CoincellDeck(name=name)
+    cd.setup()
+    return cd
+
+
+if __name__ == "__main__":
+    deck = create_coin_cell_deck()
+    print(deck)

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv

@@ -0,0 +1,133 @@
+Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
+COIL_SYS_START_CMD,BOOL,,,,coil,8010,
+COIL_SYS_STOP_CMD,BOOL,,,,coil,8020,
+COIL_SYS_RESET_CMD,BOOL,,,,coil,8030,
+COIL_SYS_HAND_CMD,BOOL,,,,coil,8040,
+COIL_SYS_AUTO_CMD,BOOL,,,,coil,8050,
+COIL_SYS_INIT_CMD,BOOL,,,,coil,8060,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,8700,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,8710,unilab_rec_msg_succ_cmd
+COIL_SYS_START_STATUS,BOOL,,,,coil,8210,
+COIL_SYS_STOP_STATUS,BOOL,,,,coil,8220,
+COIL_SYS_RESET_STATUS,BOOL,,,,coil,8230,
+COIL_SYS_HAND_STATUS,BOOL,,,,coil,8240,
+COIL_SYS_AUTO_STATUS,BOOL,,,,coil,8250,
+COIL_SYS_INIT_STATUS,BOOL,,,,coil,8260,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,8500,
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,8510,request_send_msg_status
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,11000,
+REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,11002,unilab_send_msg_electrolyte_num
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,11004,unilab_send_msg_electrolyte_vol
+REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,11006,unilab_send_msg_assembly_type
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,11008,unilab_send_msg_assembly_pressure
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,10000,data_assembly_coin_cell_num
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,10002,data_open_circuit_voltage
+REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,10004,
+REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,10006,
+REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,10008,
+REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,10010,data_pole_weight
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,10012,data_assembly_time
+REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,10014,data_assembly_pressure
+REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,10016,data_electrolyte_volume
+REG_DATA_COIN_NUM,INT16,,,,hold_register,10018,data_coin_num
+REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,10020,data_electrolyte_code()
+REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,10030,data_coin_cell_code()
+REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,12004,data_stack_vision_code()
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,10050,data_glove_box_pressure
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,10052,data_glove_box_water_content
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,10054,data_glove_box_o2_content
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8720,
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8520,
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,496,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,10000,
+UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,8730,
+UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,8530,
+REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,10018,ASSEMBLY_TYPE7or8
+REG_UNILAB_INTERACT,BOOL,,,,coil,8450,
+,,,,,coil,8320,
+COIL_ALUMINUM_FOIL,BOOL,,,,coil,8340,
+REG_MSG_NE_PLATE_MATRIX,INT16,,,,hold_register,440,
+REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,,,hold_register,450,
+REG_MSG_TIP_BOX_MATRIX,INT16,,,,hold_register,480,
+REG_MSG_NE_PLATE_NUM,INT16,,,,hold_register,443,
+REG_MSG_SEPARATOR_PLATE_NUM,INT16,,,,hold_register,453,
+REG_MSG_PRESS_MODE,BOOL,,,,coil,8360,
+,BOOL,,,,coil,8300,
+,BOOL,,,,coil,8310,
+COIL_GB_L_IGNORE_CMD,BOOL,,,,coil,8320,
+COIL_GB_R_IGNORE_CMD,BOOL,,,,coil,8420,
+,BOOL,,,,coil,8350,
+COIL_ELECTROLYTE_DUAL_DROP_MODE,BOOL,,,,coil,8370,
+,BOOL,,,,coil,8380,
+,BOOL,,,,coil,8390,
+,BOOL,,,,coil,8400,
+,BOOL,,,,coil,8410,
+REG_MSG_DUAL_DROP_FIRST_VOLUME,INT16,,,,hold_register,4001,
+COIL_DUAL_DROP_SUCTION_TIMING,BOOL,,,,coil,8430,
+COIL_DUAL_DROP_START_TIMING,BOOL,,,,coil,8470,
+REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,,,coil,8460,
+COIL_MATERIAL_SEARCH_DIALOG_APPEAR,BOOL,,,,coil,6470,
+COIL_MATERIAL_SEARCH_CONFIRM_YES,BOOL,,,,coil,6480,
+COIL_MATERIAL_SEARCH_CONFIRM_NO,BOOL,,,,coil,6490,
+COIL_ALARM_100_SYSTEM_ERROR,BOOL,,,,coil,1000,异常100-系统异常
+COIL_ALARM_101_EMERGENCY_STOP,BOOL,,,,coil,1010,异常101-急停
+COIL_ALARM_111_GLOVEBOX_EMERGENCY_STOP,BOOL,,,,coil,1110,异常111-手套箱急停
+COIL_ALARM_112_GLOVEBOX_GRATING_BLOCKED,BOOL,,,,coil,1120,异常112-手套箱内光栅遮挡
+COIL_ALARM_160_PIPETTE_TIP_SHORTAGE,BOOL,,,,coil,1600,异常160-移液枪头缺料
+COIL_ALARM_161_POSITIVE_SHELL_SHORTAGE,BOOL,,,,coil,1610,异常161-正极壳缺料
+COIL_ALARM_162_ALUMINUM_FOIL_SHORTAGE,BOOL,,,,coil,1620,异常162-铝箔垫缺料
+COIL_ALARM_163_POSITIVE_PLATE_SHORTAGE,BOOL,,,,coil,1630,异常163-正极片缺料
+COIL_ALARM_164_SEPARATOR_SHORTAGE,BOOL,,,,coil,1640,异常164-隔膜缺料
+COIL_ALARM_165_NEGATIVE_PLATE_SHORTAGE,BOOL,,,,coil,1650,异常165-负极片缺料
+COIL_ALARM_166_FLAT_WASHER_SHORTAGE,BOOL,,,,coil,1660,异常166-平垫缺料
+COIL_ALARM_167_SPRING_WASHER_SHORTAGE,BOOL,,,,coil,1670,异常167-弹垫缺料
+COIL_ALARM_168_NEGATIVE_SHELL_SHORTAGE,BOOL,,,,coil,1680,异常168-负极壳缺料
+COIL_ALARM_169_FINISHED_BATTERY_FULL,BOOL,,,,coil,1690,异常169-成品电池满料
+COIL_ALARM_201_SERVO_AXIS_01_ERROR,BOOL,,,,coil,2010,异常201-伺服轴01异常
+COIL_ALARM_202_SERVO_AXIS_02_ERROR,BOOL,,,,coil,2020,异常202-伺服轴02异常
+COIL_ALARM_203_SERVO_AXIS_03_ERROR,BOOL,,,,coil,2030,异常203-伺服轴03异常
+COIL_ALARM_204_SERVO_AXIS_04_ERROR,BOOL,,,,coil,2040,异常204-伺服轴04异常
+COIL_ALARM_205_SERVO_AXIS_05_ERROR,BOOL,,,,coil,2050,异常205-伺服轴05异常
+COIL_ALARM_206_SERVO_AXIS_06_ERROR,BOOL,,,,coil,2060,异常206-伺服轴06异常
+COIL_ALARM_207_SERVO_AXIS_07_ERROR,BOOL,,,,coil,2070,异常207-伺服轴07异常
+COIL_ALARM_208_SERVO_AXIS_08_ERROR,BOOL,,,,coil,2080,异常208-伺服轴08异常
+COIL_ALARM_209_SERVO_AXIS_09_ERROR,BOOL,,,,coil,2090,异常209-伺服轴09异常
+COIL_ALARM_210_SERVO_AXIS_10_ERROR,BOOL,,,,coil,2100,异常210-伺服轴10异常
+COIL_ALARM_211_SERVO_AXIS_11_ERROR,BOOL,,,,coil,2110,异常211-伺服轴11异常
+COIL_ALARM_212_SERVO_AXIS_12_ERROR,BOOL,,,,coil,2120,异常212-伺服轴12异常
+COIL_ALARM_213_SERVO_AXIS_13_ERROR,BOOL,,,,coil,2130,异常213-伺服轴13异常
+COIL_ALARM_214_SERVO_AXIS_14_ERROR,BOOL,,,,coil,2140,异常214-伺服轴14异常
+COIL_ALARM_250_OTHER_COMPONENT_ERROR,BOOL,,,,coil,2500,异常250-其他元件异常
+COIL_ALARM_251_PIPETTE_COMM_ERROR,BOOL,,,,coil,2510,异常251-移液枪通讯异常
+COIL_ALARM_252_PIPETTE_ALARM,BOOL,,,,coil,2520,异常252-移液枪报警
+COIL_ALARM_256_ELECTRIC_GRIPPER_ERROR,BOOL,,,,coil,2560,异常256-电爪异常
+COIL_ALARM_262_RB_UNKNOWN_POSITION_ERROR,BOOL,,,,coil,2620,异常262-RB报警：未知点位错误
+COIL_ALARM_263_RB_XYZ_PARAM_LIMIT_ERROR,BOOL,,,,coil,2630,异常263-RB报警：X、Y、Z参数超限制
+COIL_ALARM_264_RB_VISION_PARAM_ERROR,BOOL,,,,coil,2640,异常264-RB报警：视觉参数误差过大
+COIL_ALARM_265_RB_NOZZLE_1_PICK_FAIL,BOOL,,,,coil,2650,异常265-RB报警：1#吸嘴取料失败
+COIL_ALARM_266_RB_NOZZLE_2_PICK_FAIL,BOOL,,,,coil,2660,异常266-RB报警：2#吸嘴取料失败
+COIL_ALARM_267_RB_NOZZLE_3_PICK_FAIL,BOOL,,,,coil,2670,异常267-RB报警：3#吸嘴取料失败
+COIL_ALARM_268_RB_NOZZLE_4_PICK_FAIL,BOOL,,,,coil,2680,异常268-RB报警：4#吸嘴取料失败
+COIL_ALARM_269_RB_TRAY_PICK_FAIL,BOOL,,,,coil,2690,异常269-RB报警：取物料盘失败
+COIL_ALARM_280_RB_COLLISION_ERROR,BOOL,,,,coil,2800,异常280-RB碰撞异常
+COIL_ALARM_290_VISION_SYSTEM_COMM_ERROR,BOOL,,,,coil,2900,异常290-视觉系统通讯异常
+COIL_ALARM_291_VISION_ALIGNMENT_NG,BOOL,,,,coil,2910,异常291-视觉对位NG异常
+COIL_ALARM_292_BARCODE_SCANNER_COMM_ERROR,BOOL,,,,coil,2920,异常292-扫码枪通讯异常
+COIL_ALARM_310_OCV_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3100,异常310-开电移载吸嘴吸真空异常
+COIL_ALARM_311_OCV_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3110,异常311-开电移载吸嘴破真空异常
+COIL_ALARM_312_WEIGHT_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3120,异常312-称重移载吸嘴吸真空异常
+COIL_ALARM_313_WEIGHT_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3130,异常313-称重移载吸嘴破真空异常
+COIL_ALARM_340_OCV_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3400,异常340-开路电压吸嘴移载气缸异常
+COIL_ALARM_342_OCV_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3420,异常342-开路电压吸嘴升降气缸异常
+COIL_ALARM_344_OCV_CRIMPING_CYLINDER_ERROR,BOOL,,,,coil,3440,异常344-开路电压旋压气缸异常
+COIL_ALARM_350_WEIGHT_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3500,异常350-称重吸嘴移载气缸异常
+COIL_ALARM_352_WEIGHT_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3520,异常352-称重吸嘴升降气缸异常
+COIL_ALARM_354_CLEANING_CLOTH_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3540,异常354-清洗无尘布移载气缸异常
+COIL_ALARM_356_CLEANING_CLOTH_PRESS_CYLINDER_ERROR,BOOL,,,,coil,3560,异常356-清洗无尘布压紧气缸异常
+COIL_ALARM_360_ELECTROLYTE_BOTTLE_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3600,异常360-电解液瓶定位气缸异常
+COIL_ALARM_362_PIPETTE_TIP_BOX_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3620,异常362-移液枪头盒定位气缸异常
+COIL_ALARM_364_REAGENT_BOTTLE_GRIPPER_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3640,异常364-试剂瓶夹爪升降气缸异常
+COIL_ALARM_366_REAGENT_BOTTLE_GRIPPER_CYLINDER_ERROR,BOOL,,,,coil,3660,异常366-试剂瓶夹爪气缸异常
+COIL_ALARM_370_PRESS_MODULE_BLOW_CYLINDER_ERROR,BOOL,,,,coil,3700,异常370-压制模块吹气气缸异常
+COIL_ALARM_151_ELECTROLYTE_BOTTLE_POSITION_ERROR,BOOL,,,,coil,1510,异常151-电解液瓶定位在籍异常
+COIL_ALARM_152_ELECTROLYTE_BOTTLE_CAP_ERROR,BOOL,,,,coil,1520,异常152-电解液瓶盖在籍异常