更新自动化配置抓取位置

This reverts commit 4595f86725, reversing
changes made to 1340bae838.

.conda/base/recipe.yaml

@@ -1,62 +0,0 @@
-# unilabos: Production package (depends on unilabos-env + pip unilabos)
-# For production deployment
-
-package:
-  name: unilabos
-  version: 0.10.18
-
-source:
-  path: ../../unilabos
-  target_directory: unilabos
-
-build:
-  python:
-    entry_points:
-    - unilab = unilabos.app.main:main
-  script:
-  - set PIP_NO_INDEX=
-  - if: win
-    then:
-    - copy %RECIPE_DIR%\..\..\MANIFEST.in %SRC_DIR%
-    - copy %RECIPE_DIR%\..\..\setup.cfg %SRC_DIR%
-    - copy %RECIPE_DIR%\..\..\setup.py %SRC_DIR%
-    - pip install %SRC_DIR%
-  - if: unix
-    then:
-    - cp $RECIPE_DIR/../../MANIFEST.in $SRC_DIR
-    - cp $RECIPE_DIR/../../setup.cfg $SRC_DIR
-    - cp $RECIPE_DIR/../../setup.py $SRC_DIR
-    - pip install $SRC_DIR
-
-requirements:
-  host:
-  - python ==3.11.14
-  - pip
-  - setuptools
-  - zstd
-  - zstandard
-  run:
-  - zstd
-  - zstandard
-  - networkx
-  - typing_extensions
-  - websockets
-  - pint
-  - fastapi
-  - jinja2
-  - requests
-  - uvicorn
-  - if: not osx
-    then:
-    - opcua
-  - pyserial
-  - pandas
-  - pymodbus
-  - matplotlib
-  - pylibftdi
-  - uni-lab::unilabos-env ==0.10.18
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS - Production package with minimal ROS2 dependencies"

.conda/environment/recipe.yaml

@@ -1,39 +0,0 @@
-# unilabos-env: conda environment dependencies (ROS2 + conda packages)
-
-package:
-  name: unilabos-env
-  version: 0.10.18
-
-build:
-  noarch: generic
-
-requirements:
-  run:
-  # Python
-  - zstd
-  - zstandard
-  - conda-forge::python ==3.11.14
-  - conda-forge::opencv
-  # ROS2 dependencies (from ci-check.yml)
-  - 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
-  - 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
-  - conda-forge::uv
-
-  # UniLabOS custom messages
-  - uni-lab::ros-humble-unilabos-msgs
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS Environment - ROS2 and conda dependencies"

.conda/full/recipe.yaml

@@ -1,42 +0,0 @@
-# unilabos-full: Full package with all features
-# Depends on unilabos + complete ROS2 desktop + dev tools
-
-package:
-  name: unilabos-full
-  version: 0.10.18
-
-build:
-  noarch: generic
-
-requirements:
-  run:
-  # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.10.18
-  # Documentation tools
-  - sphinx
-  - sphinx_rtd_theme
-  # Web UI
-  - gradio
-  - flask
-  # Interactive development
-  - ipython
-  - jupyter
-  - jupyros
-  - colcon-common-extensions
-  # ROS2 full desktop (includes rviz2, gazebo, etc.)
-  - robostack-staging::ros-humble-desktop-full
-  # Navigation and motion control
-  - ros-humble-navigation2
-  - ros-humble-ros2-control
-  - ros-humble-robot-state-publisher
-  - ros-humble-joint-state-publisher
-  # MoveIt motion planning
-  - ros-humble-moveit
-  - ros-humble-moveit-servo
-  # Simulation
-  - ros-humble-simulation
-
-about:
-  repository: https://github.com/deepmodeling/Uni-Lab-OS
-  license: GPL-3.0-only
-  description: "UniLabOS Full - Complete package with ROS2 Desktop, MoveIt, Navigation2, Gazebo, Jupyter"

.conda/recipe.yaml

@@ -0,0 +1,91 @@
+package:
+  name: unilabos
+  version: 0.10.15
+
+source:
+  path: ../unilabos
+  target_directory: unilabos
+
+build:
+  python:
+    entry_points:
+    - unilab = unilabos.app.main:main
+  script:
+  - set PIP_NO_INDEX=
+  - if: win
+    then:
+    - copy %RECIPE_DIR%\..\MANIFEST.in %SRC_DIR%
+    - copy %RECIPE_DIR%\..\setup.cfg %SRC_DIR%
+    - copy %RECIPE_DIR%\..\setup.py %SRC_DIR%
+    - call %PYTHON% -m pip install %SRC_DIR%
+  - if: unix
+    then:
+    - cp $RECIPE_DIR/../MANIFEST.in $SRC_DIR
+    - cp $RECIPE_DIR/../setup.cfg $SRC_DIR
+    - cp $RECIPE_DIR/../setup.py $SRC_DIR
+    - $PYTHON -m pip install $SRC_DIR
+
+requirements:
+  host:
+  - python ==3.11.11
+  - pip
+  - setuptools
+  - zstd
+  - zstandard
+  run:
+  - conda-forge::python ==3.11.11
+  - compilers
+  - cmake
+  - zstd
+  - zstandard
+  - ninja
+  - if: unix
+    then:
+    - make
+  - sphinx
+  - sphinx_rtd_theme
+  - numpy
+  - scipy
+  - pandas
+  - networkx
+  - matplotlib
+  - pint
+  - pyserial
+  - pyusb
+  - pylibftdi
+  - pymodbus
+  - python-can
+  - pyvisa
+  - opencv
+  - pydantic
+  - fastapi
+  - uvicorn
+  - gradio
+  - flask
+  - websockets
+  - ipython
+  - jupyter
+  - jupyros
+  - colcon-common-extensions
+  - robostack-staging::ros-humble-desktop-full
+  - robostack-staging::ros-humble-control-msgs
+  - robostack-staging::ros-humble-sensor-msgs
+  - robostack-staging::ros-humble-trajectory-msgs
+  - ros-humble-navigation2
+  - ros-humble-ros2-control
+  - ros-humble-robot-state-publisher
+  - ros-humble-joint-state-publisher
+  - ros-humble-rosbridge-server
+  - ros-humble-cv-bridge
+  - ros-humble-tf2
+  - ros-humble-moveit
+  - ros-humble-moveit-servo
+  - ros-humble-simulation
+  - ros-humble-tf-transformations
+  - transforms3d
+  - uni-lab::ros-humble-unilabos-msgs
+
+about:
+  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  license: GPL-3.0-only
+  description: "Uni-Lab-OS"

.conda/scripts/post-link.bat

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

.conda/scripts/post-link.sh

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

.cursor/rules/device-drivers.mdc

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

.cursor/rules/protocol-development.mdc

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

.cursor/rules/registry-config.mdc

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

.cursor/rules/ros-integration.mdc

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

.cursor/rules/testing-patterns.mdc

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

.cursor/rules/unilabos-project.mdc

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

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

@@ -1,24 +0,0 @@
----
-name: add-device
-description: Guide for adding new devices to Uni-Lab-OS (接入新设备). Walks through device category selection (thing model), communication protocol, command protocol collection, driver creation, registry YAML, and graph file setup. Use when the user wants to add/integrate a new device, create a device driver, write a device class, configure device registry, or mentions 接入设备/添加设备/设备驱动/物模型.
----
-
-# 添加新设备到 Uni-Lab-OS
-
-**第一步：** 使用 Read 工具读取 `docs/ai_guides/add_device.md`，获取完整的设备接入指南并严格遵循。
-
-该指南包含：
-- 8 步完整流程（设备类别、通信协议、指令收集、接口对齐、驱动创建、注册表、图文件、验证）
-- 所有物模型代码模板（注射泵、电磁阀、蠕动泵、温控、电机等）
-- 通信协议代码片段（Serial、Modbus、TCP、HTTP、OPC UA）
-- 现有设备接口快照（用于第四步对齐，包含参数名、status_types、方法签名）
-- 常见错误检查清单
-
-**Cursor 工具映射：**
-
-| 指南中的操作 | Cursor 中使用的工具 |
-|---|---|
-| 向用户确认设备类别、协议等信息 | 使用 AskQuestion 工具 |
-| 搜索已有设备注册表 | 使用 Grep 在 `unilabos/registry/devices/` 中搜索 |
-| 读取用户提供的协议文档/SDK 代码 | 使用 Read 工具 |
-| 第四步对齐：查找同类设备接口 | 优先使用 Grep 搜索仓库中的最新注册表；指南中的「现有设备接口快照」作为兜底参考 |

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

@@ -1,323 +0,0 @@
----
-name: add-protocol
-description: Guide for adding new experiment protocols to Uni-Lab-OS (添加新实验操作协议). Walks through ROS Action definition, Pydantic model creation, protocol generator implementation, and registration. Use when the user wants to add a new protocol, create a compile function, implement an experiment operation, or mentions 协议/protocol/编译/compile/实验操作.
----
-
-# 添加新实验操作协议（Protocol）
-
-Protocol 是对实验有意义的完整动作（如泵转移、过滤、溶解），需要多设备协同。`compile/` 中的生成函数根据设备连接图将抽象操作"编译"为设备指令序列。
-
-添加一个 Protocol 需修改 **6 个文件**，按以下流程执行。
-
----
-
-## 第一步：确认协议信息
-
-向用户确认：
-
-| 信息 | 示例 |
-|------|------|
-| 协议英文名 | `MyNewProtocol` |
-| 操作描述 | 将固体样品研磨至目标粒径 |
-| Goal 参数（必需 + 可选） | `vessel: dict`, `time: float = 300.0` |
-| Result 字段 | `success: bool`, `message: str` |
-| 需要哪些设备协同 | 研磨器、搅拌器 |
-
----
-
-## 第二步：创建 ROS Action 定义
-
-路径：`unilabos_msgs/action/<ActionName>.action`
-
-三段式结构（Goal / Result / Feedback），用 `---` 分隔：
-
-```
-# Goal
-Resource vessel
-float64 time
-string mode
----
-# Result
-bool success
-string return_info
----
-# Feedback
-string status
-string current_device
-builtin_interfaces/Duration time_spent
-builtin_interfaces/Duration time_remaining
-```
-
-**类型映射：**
-
-| Python 类型 | ROS 类型 | 说明 |
-|------------|----------|------|
-| `dict` | `Resource` | 容器/设备引用，自定义消息类型 |
-| `float` | `float64` | |
-| `int` | `int32` | |
-| `str` | `string` | |
-| `bool` | `bool` | |
-
-> `Resource` 是 `unilabos_msgs/msg/Resource.msg` 中定义的自定义消息类型。
-
----
-
-## 第三步：注册 Action 到 CMakeLists
-
-在 `unilabos_msgs/CMakeLists.txt` 的 `set(action_files ...)` 块中添加：
-
-```cmake
-"action/MyNewAction.action"
-```
-
-> 调试时需编译：`cd unilabos_msgs && colcon build && source ./install/local_setup.sh && cd ..`
-> PR 合并后 CI/CD 自动发布，`mamba update ros-humble-unilabos-msgs` 即可。
-
----
-
-## 第四步：创建 Pydantic 模型
-
-在 `unilabos/messages/__init__.py` 中添加（位于 `# Start Protocols` 和 `# End Protocols` 之间）：
-
-```python
-class MyNewProtocol(BaseModel):
-    # === 必需参数 ===
-    vessel: dict = Field(..., description="目标容器")
-    
-    # === 可选参数 ===
-    time: float = Field(300.0, description="操作时间 (秒)")
-    mode: str = Field("default", description="操作模式")
-    
-    def model_post_init(self, __context):
-        """参数验证和修正"""
-        if self.time <= 0:
-            self.time = 300.0
-```
-
-**规则：**
-- 参数名必须与 `.action` 文件中 Goal 字段完全一致
-- `dict` 类型对应 `.action` 中的 `Resource`
-- 将类名加入文件末尾的 `__all__` 列表
-
----
-
-## 第五步：实现协议生成函数
-
-路径：`unilabos/compile/<protocol_name>_protocol.py`
-
-```python
-import networkx as nx
-from typing import List, Dict, Any
-
-
-def generate_my_new_protocol(
-    G: nx.DiGraph,
-    vessel: dict,
-    time: float = 300.0,
-    mode: str = "default",
-    **kwargs,
-) -> List[Dict[str, Any]]:
-    """将 MyNewProtocol 编译为设备动作序列。
-    
-    Args:
-        G: 设备连接图（NetworkX），节点为设备/容器，边为物理连接
-        vessel: 目标容器 {"id": "reactor_1"}
-        time: 操作时间（秒）
-        mode: 操作模式
-    
-    Returns:
-        动作列表，每个元素为:
-        - dict: 单步动作
-        - list[dict]: 并行动作
-    """
-    from unilabos.compile.utils.vessel_parser import get_vessel
-    
-    vessel_id, vessel_data = get_vessel(vessel)
-    actions = []
-    
-    # 查找相关设备（通过图的连接关系）
-    # 生成动作序列
-    actions.append({
-        "device_id": "target_device_id",
-        "action_name": "some_action",
-        "action_kwargs": {"param": "value"}
-    })
-    
-    # 等待
-    actions.append({
-        "action_name": "wait",
-        "action_kwargs": {"time": time}
-    })
-    
-    return actions
-```
-
-### 动作字典格式
-
-```python
-# 单步动作（发给子设备）
-{"device_id": "pump_1", "action_name": "set_position", "action_kwargs": {"position": 10.0}}
-
-# 发给工作站自身
-{"device_id": "self", "action_name": "my_action", "action_kwargs": {...}}
-
-# 等待
-{"action_name": "wait", "action_kwargs": {"time": 5.0}}
-
-# 并行动作（列表嵌套）
-[
-    {"device_id": "pump_1", "action_name": "set_position", "action_kwargs": {"position": 10.0}},
-    {"device_id": "stirrer_1", "action_name": "start_stir", "action_kwargs": {"stir_speed": 300}}
-]
-```
-
-### 关于 `vessel` 参数类型
-
-现有协议的 `vessel` 参数类型不统一：
-- 新协议趋势：使用 `dict`（如 `{"id": "reactor_1"}`）
-- 旧协议：使用 `str`（如 `"reactor_1"`）
-- 兼容写法：`Union[str, dict]`
-
-**建议新协议统一使用 `dict` 类型**，通过 `get_vessel()` 兼容两种输入。
-
-### 公共工具函数（`unilabos/compile/utils/`）
-
-| 函数 | 用途 |
-|------|------|
-| `get_vessel(vessel)` | 解析容器参数为 `(vessel_id, vessel_data)`，兼容 dict 和 str |
-| `find_solvent_vessel(G, solvent)` | 根据溶剂名查找容器（精确→命名规则→模糊→液体类型） |
-| `find_reagent_vessel(G, reagent)` | 根据试剂名查找容器（支持固体和液体） |
-| `find_connected_stirrer(G, vessel)` | 查找与容器相连的搅拌器 |
-| `find_solid_dispenser(G)` | 查找固体加样器 |
-
-### 协议内专属查找函数
-
-许多协议在自己的文件内定义了专属的 `find_*` 函数（不在 `utils/` 中）。编写新协议时，优先复用 `utils/` 中的公共函数；如需特殊查找逻辑，在协议文件内部定义即可：
-
-```python
-def find_my_special_device(G: nx.DiGraph, vessel: str) -> str:
-    """查找与容器相关的特殊设备"""
-    for node in G.nodes():
-        if 'my_device_type' in G.nodes[node].get('class', '').lower():
-            return node
-    raise ValueError("未找到特殊设备")
-```
-
-### 复用已有协议
-
-复杂协议通常组合已有协议：
-
-```python
-from unilabos.compile.pump_protocol import generate_pump_protocol_with_rinsing
-
-actions.extend(generate_pump_protocol_with_rinsing(
-    G, from_vessel=solvent_vessel, to_vessel=vessel, volume=volume
-))
-```
-
-### 图查询模式
-
-```python
-# 查找与容器相连的特定类型设备
-for neighbor in G.neighbors(vessel_id):
-    node_data = G.nodes[neighbor]
-    if "heater" in node_data.get("class", ""):
-        heater_id = neighbor
-        break
-
-# 查找最短路径（泵转移）
-path = nx.shortest_path(G, source=from_vessel_id, target=to_vessel_id)
-```
-
----
-
-## 第六步：注册协议生成函数
-
-在 `unilabos/compile/__init__.py` 中：
-
-1. 顶部添加导入：
-
-```python
-from .my_new_protocol import generate_my_new_protocol
-```
-
-2. 在 `action_protocol_generators` 字典中添加映射：
-
-```python
-action_protocol_generators = {
-    # ... 已有协议
-    MyNewProtocol: generate_my_new_protocol,
-}
-```
-
----
-
-## 第七步：配置图文件
-
-在工作站的图文件中，将协议名加入 `protocol_type`：
-
-```json
-{
-    "id": "my_station",
-    "class": "workstation",
-    "config": {
-        "protocol_type": ["PumpTransferProtocol", "MyNewProtocol"]
-    }
-}
-```
-
----
-
-## 第八步：验证
-
-```bash
-# 1. 模块可导入
-python -c "from unilabos.messages import MyNewProtocol; print(MyNewProtocol.model_fields)"
-
-# 2. 生成函数可导入
-python -c "from unilabos.compile import action_protocol_generators; print(list(action_protocol_generators.keys()))"
-
-# 3. 启动测试（可选）
-unilab -g <graph>.json --complete_registry
-```
-
----
-
-## 工作流清单
-
-```
-协议接入进度：
-- [ ] 1. 确认协议名、参数、涉及设备
-- [ ] 2. 创建 .action 文件 (unilabos_msgs/action/<Name>.action)
-- [ ] 3. 注册到 CMakeLists.txt
-- [ ] 4. 创建 Pydantic 模型 (unilabos/messages/__init__.py) + 更新 __all__
-- [ ] 5. 实现生成函数 (unilabos/compile/<name>_protocol.py)
-- [ ] 6. 注册到 compile/__init__.py
-- [ ] 7. 配置图文件 protocol_type
-- [ ] 8. 验证
-```
-
----
-
-## 高级模式
-
-实现复杂协议时，详见 [reference.md](reference.md)：协议运行时数据流、mock graph 测试模式、单位解析工具（`unit_parser.py`）、复杂协议组合模式（以 dissolve 为例）。
-
----
-
-## 现有协议速查
-
-| 协议 | Pydantic 类 | 生成函数 | 核心参数 |
-|------|-------------|---------|---------|
-| 泵转移 | `PumpTransferProtocol` | `generate_pump_protocol_with_rinsing` | `from_vessel, to_vessel, volume` |
-| 简单转移 | `TransferProtocol` | `generate_pump_protocol` | `from_vessel, to_vessel, volume` |
-| 加样 | `AddProtocol` | `generate_add_protocol` | `vessel, reagent, volume` |
-| 过滤 | `FilterProtocol` | `generate_filter_protocol` | `vessel, filtrate_vessel` |
-| 溶解 | `DissolveProtocol` | `generate_dissolve_protocol` | `vessel, solvent, volume` |
-| 加热/冷却 | `HeatChillProtocol` | `generate_heat_chill_protocol` | `vessel, temp, time` |
-| 搅拌 | `StirProtocol` | `generate_stir_protocol` | `vessel, time` |
-| 分离 | `SeparateProtocol` | `generate_separate_protocol` | `from_vessel, separation_vessel, solvent` |
-| 蒸发 | `EvaporateProtocol` | `generate_evaporate_protocol` | `vessel, pressure, temp, time` |
-| 清洗 | `CleanProtocol` | `generate_clean_protocol` | `vessel, solvent, volume` |
-| 离心 | `CentrifugeProtocol` | `generate_centrifuge_protocol` | `vessel, speed, time` |
-| 抽气充气 | `EvacuateAndRefillProtocol` | `generate_evacuateandrefill_protocol` | `vessel, gas` |

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

@@ -1,207 +0,0 @@
-# 协议高级参考
-
-本文件是 SKILL.md 的补充，包含协议运行时数据流、测试模式、单位解析工具和复杂协议组合模式。Agent 在需要实现这些功能时按需阅读。
-
----
-
-## 1. 协议运行时数据流
-
-从图文件到协议执行的完整链路：
-
-```
-实验图 JSON
-    ↓  graphio.read_node_link_json()
-physical_setup_graph (NetworkX DiGraph)
-    ↓  ROS2WorkstationNode._setup_protocol_names(protocol_type)
-为每个 protocol_name 创建 ActionServer
-    ↓  收到 Action Goal
-_create_protocol_execute_callback()
-    ↓  convert_from_ros_msg_with_mapping(goal, mapping)
-protocol_kwargs (Python dict)
-    ↓  向 Host 查询 Resource 类型参数的当前状态
-protocol_kwargs 更新（vessel 带上 children、data 等）
-    ↓  protocol_steps_generator(G=physical_setup_graph, **protocol_kwargs)
-List[Dict] 动作序列
-    ↓  逐步 execute_single_action / 并行 create_task
-子设备 ActionClient 执行
-```
-
-### `_setup_protocol_names` 核心逻辑
-
-```python
-def _setup_protocol_names(self, protocol_type):
-    if isinstance(protocol_type, str):
-        self.protocol_names = [p.strip() for p in protocol_type.split(",")]
-    else:
-        self.protocol_names = protocol_type
-    self.protocol_action_mappings = {}
-    for protocol_name in self.protocol_names:
-        protocol_type = globals()[protocol_name]  # 从 messages 模块取 Pydantic 类
-        self.protocol_action_mappings[protocol_name] = get_action_type(protocol_type)
-```
-
-### `_create_protocol_execute_callback` 关键步骤
-
-1. `convert_from_ros_msg_with_mapping(goal, action_value_mapping["goal"])` — ROS Goal → Python dict
-2. 对 `Resource` 类型字段，通过 `resource_get` Service 查询 Host 的最新资源状态
-3. `protocol_steps_generator(G=physical_setup_graph, **protocol_kwargs)` — 调用编译函数
-4. 遍历 steps：`dict` 串行执行，`list` 并行执行
-5. `execute_single_action` 通过 `_action_clients[device_id]` 向子设备发送 Action Goal
-6. 执行完毕后通过 `resource_update` Service 更新资源状态
-
----
-
-## 2. 测试模式
-
-### 2.1 协议文件内测试函数
-
-许多协议文件末尾有 `test_*` 函数，主要测试参数解析工具：
-
-```python
-def test_dissolve_protocol():
-    """测试溶解协议的各种参数解析"""
-    volumes = ["10 mL", "?", 10.0, "1 L", "500 μL"]
-    for vol in volumes:
-        result = parse_volume_input(vol)
-        print(f"体积解析: {vol} → {result}mL")
-
-    masses = ["2.9 g", "?", 2.5, "500 mg"]
-    for mass in masses:
-        result = parse_mass_input(mass)
-        print(f"质量解析: {mass} → {result}g")
-```
-
-### 2.2 使用 mock graph 测试协议生成器
-
-推荐的端到端测试模式：
-
-```python
-import pytest
-import networkx as nx
-from unilabos.compile.stir_protocol import generate_stir_protocol
-
-
-@pytest.fixture
-def topology_graph():
-    """创建测试拓扑图"""
-    G = nx.DiGraph()
-    G.add_node("flask_1", **{"class": "flask", "type": "container"})
-    G.add_node("stirrer_1", **{"class": "virtual_stirrer", "type": "device"})
-    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"
-```
-
-**要点：**
-- 用 `nx.DiGraph()` 构建最小拓扑
-- `add_node(id, **attrs)` 设置 `class`、`type`、`data` 等
-- `add_edge(src, dst)` 建立物理连接
-- 协议内的 `find_*` 函数依赖这些节点和边
-
----
-
-## 3. 单位解析工具
-
-路径：`unilabos/compile/utils/unit_parser.py`
-
-| 函数 | 输入 | 返回 | 默认值 |
-|------|------|------|--------|
-| `parse_volume_input(input, default_unit)` | `"100 mL"`, `"2.5 L"`, `"500 μL"`, `10.0`, `"?"` | mL (float) | 50.0 |
-| `parse_mass_input(input)` | `"19.3 g"`, `"500 mg"`, `2.5`, `"?"` | g (float) | 1.0 |
-| `parse_time_input(input)` | `"30 min"`, `"1 h"`, `"300"`, `60.0`, `"?"` | 秒 (float) | 60.0 |
-
-支持的单位：
-
-- **体积**: mL, L, μL/uL, milliliter, liter, microliter
-- **质量**: g, mg, kg, gram, milligram, kilogram
-- **时间**: s/sec/second, min/minute, h/hr/hour, d/day
-
-特殊值 `"?"`、`"unknown"`、`"tbd"` 返回默认值。
-
----
-
-## 4. 复杂协议组合模式
-
-以 `dissolve_protocol` 为例，展示如何组合多个子操作：
-
-### 整体流程
-
-```
-1. 解析参数 (parse_volume_input, parse_mass_input, parse_time_input)
-2. 设备发现 (find_connected_heatchill, find_connected_stirrer, find_solid_dispenser)
-3. 判断溶解类型 (液体 vs 固体)
-4. 组合动作序列:
-   a. heat_chill_start / start_stir  (启动加热/搅拌)
-   b. wait                           (等待温度稳定)
-   c. pump_protocol_with_rinsing     (液体转移, 通过 extend 拼接)
-      或 add_solid                   (固体加样)
-   d. heat_chill / stir / wait       (溶解等待)
-   e. heat_chill_stop                (停止加热)
-```
-
-### 关键代码模式
-
-**设备发现 → 条件组合：**
-
-```python
-heatchill_id = find_connected_heatchill(G, vessel_id)
-stirrer_id = find_connected_stirrer(G, vessel_id)
-solid_dispenser_id = find_solid_dispenser(G)
-
-actions = []
-
-# 启动阶段
-if heatchill_id and temp > 25.0:
-    actions.append({
-        "device_id": heatchill_id,
-        "action_name": "heat_chill_start",
-        "action_kwargs": {"vessel": {"id": vessel_id}, "temp": temp}
-    })
-    actions.append({"action_name": "wait", "action_kwargs": {"time": 30}})
-elif stirrer_id:
-    actions.append({
-        "device_id": stirrer_id,
-        "action_name": "start_stir",
-        "action_kwargs": {"vessel": {"id": vessel_id}, "stir_speed": stir_speed}
-    })
-
-# 转移阶段（复用已有协议）
-pump_actions = generate_pump_protocol_with_rinsing(
-    G=G, from_vessel=solvent_vessel, to_vessel=vessel_id, volume=volume
-)
-actions.extend(pump_actions)
-
-# 等待阶段
-if heatchill_id:
-    actions.append({
-        "device_id": heatchill_id,
-        "action_name": "heat_chill",
-        "action_kwargs": {"vessel": {"id": vessel_id}, "temp": temp, "time": time}
-    })
-else:
-    actions.append({"action_name": "wait", "action_kwargs": {"time": time}})
-```
-
----
-
-## 5. 关键路径
-
-| 内容 | 路径 |
-|------|------|
-| 协议执行回调 | `unilabos/ros/nodes/presets/workstation.py` |
-| ROS 消息映射 | `unilabos/ros/msgs/message_converter.py` |
-| 物理拓扑图 | `unilabos/resources/graphio.py` (`physical_setup_graph`) |
-| 单位解析 | `unilabos/compile/utils/unit_parser.py` |
-| 容器解析 | `unilabos/compile/utils/vessel_parser.py` |
-| 溶解协议（组合示例） | `unilabos/compile/dissolve_protocol.py` |

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

@@ -1,371 +0,0 @@
----
-name: add-resource
-description: Guide for adding new resources (materials, bottles, carriers, decks, warehouses) to Uni-Lab-OS (添加新物料/资源). Covers Bottle, Carrier, Deck, WareHouse definitions and registry YAML. Use when the user wants to add resources, define materials, create a deck layout, add bottles/carriers/plates, or mentions 物料/资源/resource/bottle/carrier/deck/plate/warehouse.
----
-
-# 添加新物料资源
-
-Uni-Lab-OS 的资源体系基于 PyLabRobot，通过扩展实现 Bottle、Carrier、WareHouse、Deck 等实验室物料管理。
-
----
-
-## 第一步：确认资源类型
-
-向用户确认需要添加的资源类型：
-
-| 类型 | 基类 | 用途 | 示例 |
-|------|------|------|------|
-| **Bottle** | `Well` (PyLabRobot) | 单个容器（瓶、小瓶、烧杯、反应器） | 试剂瓶、粉末瓶 |
-| **BottleCarrier** | `ItemizedCarrier` | 多槽位载架（放多个 Bottle） | 6 位试剂架、枪头盒 |
-| **WareHouse** | `ItemizedCarrier` | 堆栈/仓库（放多个 Carrier） | 4x4 堆栈 |
-| **Deck** | `Deck` (PyLabRobot) | 工作站台面（放多个 WareHouse） | 反应站 Deck |
-
-**层级关系：** `Deck` → `WareHouse` → `BottleCarrier` → `Bottle`
-
-还需确认：
-- 资源所属的项目/场景（如 bioyond、battery、通用）
-- 尺寸参数（直径、高度、最大容积等）
-- 布局参数（行列数、间距等）
-
----
-
-## 第二步：创建资源定义
-
-### 文件位置
-
-```
-unilabos/resources/
-├── <project>/          # 按项目分组
-│   ├── bottles.py      # Bottle 工厂函数
-│   ├── bottle_carriers.py  # Carrier 工厂函数
-│   ├── warehouses.py   # WareHouse 工厂函数
-│   └── decks.py        # Deck 类定义
-├── itemized_carrier.py # Bottle, BottleCarrier, ItemizedCarrier 基类
-├── warehouse.py        # WareHouse 基类
-└── container.py        # 通用容器
-```
-
-### 2A. 添加 Bottle（工厂函数）
-
-```python
-from unilabos.resources.itemized_carrier import Bottle
-
-
-def My_Reagent_Bottle(
-    name: str,
-    diameter: float = 70.0,     # 瓶体直径 (mm)
-    height: float = 120.0,      # 瓶体高度 (mm)
-    max_volume: float = 500000.0,  # 最大容积 (μL)
-    barcode: str = None,
-) -> Bottle:
-    """创建试剂瓶"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="My_Reagent_Bottle",  # 唯一标识，用于注册表和物料映射
-    )
-```
-
-**Bottle 参数：**
-- `name`: 实例名称（运行时唯一）
-- `diameter`: 瓶体直径 (mm)
-- `height`: 瓶体高度 (mm)
-- `max_volume`: 最大容积 (**μL**，注意单位！500mL = 500000)
-- `barcode`: 条形码（可选）
-- `model`: 模型标识，与注册表 key 一致
-
-### 2B. 添加 BottleCarrier（工厂函数）
-
-```python
-from pylabrobot.resources import ResourceHolder
-from pylabrobot.resources.carrier import create_ordered_items_2d
-
-from unilabos.resources.itemized_carrier import BottleCarrier
-
-
-def My_6SlotCarrier(name: str) -> BottleCarrier:
-    """创建 3x2 六槽位载架"""
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=3,       # 列数
-        num_items_y=2,       # 行数
-        dx=10.0,             # X 起始偏移
-        dy=10.0,             # Y 起始偏移
-        dz=5.0,              # Z 偏移
-        item_dx=42.0,        # X 间距
-        item_dy=35.0,        # Y 间距
-        size_x=20.0,         # 槽位宽
-        size_y=20.0,         # 槽位深
-        size_z=50.0,         # 槽位高
-    )
-    carrier = BottleCarrier(
-        name=name,
-        size_x=146.0,        # 载架总宽
-        size_y=80.0,         # 载架总深
-        size_z=55.0,         # 载架总高
-        sites=sites,
-        model="My_6SlotCarrier",
-    )
-    carrier.num_items_x = 3
-    carrier.num_items_y = 2
-    carrier.num_items_z = 1
-
-    # 预装 Bottle（可选）
-    ordering = ["A01", "A02", "A03", "B01", "B02", "B03"]
-    for i in range(6):
-        carrier[i] = My_Reagent_Bottle(f"{ordering[i]}")
-
-    return carrier
-```
-
-### 2C. 添加 WareHouse（工厂函数）
-
-```python
-from unilabos.resources.warehouse import warehouse_factory
-
-
-def my_warehouse_4x4(name: str) -> "WareHouse":
-    """创建 4行x4列 堆栈仓库"""
-    return warehouse_factory(
-        name=name,
-        num_items_x=4,            # 列数
-        num_items_y=4,            # 行数
-        num_items_z=1,            # 层数（通常为 1）
-        dx=137.0,                 # X 起始偏移
-        dy=96.0,                  # Y 起始偏移
-        dz=120.0,                 # Z 起始偏移
-        item_dx=137.0,            # X 间距
-        item_dy=125.0,            # Y 间距
-        item_dz=10.0,             # Z 间距（多层时用）
-        resource_size_x=127.0,    # 槽位宽
-        resource_size_y=85.0,     # 槽位深
-        resource_size_z=100.0,    # 槽位高
-        model="my_warehouse_4x4",
-    )
-```
-
-**`warehouse_factory` 参数说明：**
-
-| 参数 | 说明 |
-|------|------|
-| `num_items_x/y/z` | 列数/行数/层数 |
-| `dx, dy, dz` | 第一个槽位的起始坐标偏移 |
-| `item_dx, item_dy, item_dz` | 相邻槽位间距 |
-| `resource_size_x/y/z` | 单个槽位的物理尺寸 |
-| `col_offset` | 列命名偏移（如设 4 则从 A05 开始） |
-| `row_offset` | 行命名偏移（如设 5 则从 F 行开始） |
-| `layout` | 排序方式：`"col-major"`（列优先，默认）/ `"row-major"`（行优先） |
-| `removed_positions` | 要移除的位置索引列表 |
-
-自动生成 `ResourceHolder` 槽位，命名规则为 `A01, B01, C01, D01, A02, ...`（列优先）或 `A01, A02, A03, A04, B01, ...`（行优先）。
-
-### 2D. 添加 Deck（类定义）
-
-```python
-from pylabrobot.resources import Deck, Coordinate
-
-
-class MyStation_Deck(Deck):
-    def __init__(
-        self,
-        name: str = "MyStation_Deck",
-        size_x: float = 2700.0,
-        size_y: float = 1080.0,
-        size_z: float = 1500.0,
-        category: str = "deck",
-        setup: bool = False,
-    ) -> None:
-        super().__init__(name=name, size_x=size_x, size_y=size_y, size_z=size_z)
-        if setup:
-            self.setup()
-
-    def setup(self) -> None:
-        self.warehouses = {
-            "仓库A": my_warehouse_4x4("仓库A"),
-            "仓库B": my_warehouse_4x4("仓库B"),
-        }
-        self.warehouse_locations = {
-            "仓库A": Coordinate(-200.0, 400.0, 0.0),
-            "仓库B": Coordinate(2350.0, 400.0, 0.0),
-        }
-        for wh_name, wh in self.warehouses.items():
-            self.assign_child_resource(wh, location=self.warehouse_locations[wh_name])
-```
-
-**Deck 要点：**
-- 继承 `pylabrobot.resources.Deck`
-- `setup()` 创建 WareHouse 并通过 `assign_child_resource` 放置到指定坐标
-- `setup` 参数控制是否在构造时自动调用 `setup()`（图文件中通过 `config.setup: true` 触发）
-
----
-
-## 第三步：创建注册表 YAML
-
-路径：`unilabos/registry/resources/<project>/<type>.yaml`
-
-### Bottle 注册
-
-```yaml
-My_Reagent_Bottle:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.my_project.bottles:My_Reagent_Bottle
-    type: pylabrobot
-  description: 我的试剂瓶
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-```
-
-### Carrier 注册
-
-```yaml
-My_6SlotCarrier:
-  category:
-  - bottle_carriers
-  class:
-    module: unilabos.resources.my_project.bottle_carriers:My_6SlotCarrier
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-```
-
-### Deck 注册
-
-```yaml
-MyStation_Deck:
-  category:
-  - deck
-  class:
-    module: unilabos.resources.my_project.decks:MyStation_Deck
-    type: pylabrobot
-  description: 我的工作站 Deck
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-```
-
-**注册表规则：**
-- `class.module` 格式为 `python.module.path:ClassName_or_FunctionName`
-- `class.type` 固定为 `pylabrobot`
-- Key（如 `My_Reagent_Bottle`）必须与工厂函数名 / 类名一致
-- `category` 按类型标注（`bottles`, `bottle_carriers`, `deck` 等）
-
----
-
-## 第四步：在图文件中引用
-
-### Deck 在工作站中的引用
-
-工作站节点通过 `deck` 字段引用，Deck 作为子节点：
-
-```json
-{
-    "id": "my_station",
-    "children": ["my_deck"],
-    "deck": {
-        "data": {
-            "_resource_child_name": "my_deck",
-            "_resource_type": "unilabos.resources.my_project.decks:MyStation_Deck"
-        }
-    }
-},
-{
-    "id": "my_deck",
-    "parent": "my_station",
-    "type": "deck",
-    "class": "MyStation_Deck",
-    "config": {"type": "MyStation_Deck", "setup": true}
-}
-```
-
-### 物料类型映射（外部系统对接时）
-
-如果工作站需要与外部系统同步物料，在 config 中配置 `material_type_mappings`：
-
-```json
-"material_type_mappings": {
-    "My_Reagent_Bottle": ["试剂瓶", "external-type-uuid"],
-    "My_6SlotCarrier": ["六槽载架", "external-type-uuid"]
-}
-```
-
----
-
-## 第五步：注册 PLR 扩展（如需要）
-
-如果添加了新的 Deck 类，需要在 `unilabos/resources/plr_additional_res_reg.py` 中导入，使 `find_subclass` 能发现它：
-
-```python
-def register():
-    from unilabos.resources.my_project.decks import MyStation_Deck
-```
-
----
-
-## 第六步：验证
-
-```bash
-# 1. 资源可导入
-python -c "from unilabos.resources.my_project.bottles import My_Reagent_Bottle; print(My_Reagent_Bottle('test'))"
-
-# 2. Deck 可创建
-python -c "
-from unilabos.resources.my_project.decks import MyStation_Deck
-d = MyStation_Deck('test', setup=True)
-print(d.children)
-"
-
-# 3. 启动测试
-unilab -g <graph>.json --complete_registry
-```
-
----
-
-## 工作流清单
-
-```
-资源接入进度：
-- [ ] 1. 确定资源类型（Bottle / Carrier / WareHouse / Deck）
-- [ ] 2. 创建资源定义（工厂函数/类）
-- [ ] 3. 创建注册表 YAML (unilabos/registry/resources/<project>/<type>.yaml)
-- [ ] 4. 在图文件中引用（如需要）
-- [ ] 5. 注册 PLR 扩展（Deck 类需要）
-- [ ] 6. 验证
-```
-
----
-
-## 高级模式
-
-实现复杂资源系统时，详见 [reference.md](reference.md)：类继承体系完整图、序列化/反序列化流程、Bioyond 物料双向同步、非瓶类资源（ElectrodeSheet / Magazine）、仓库工厂 layout 模式。
-
----
-
-## 现有资源参考
-
-| 项目 | Bottles | Carriers | WareHouses | Decks |
-|------|---------|----------|------------|-------|
-| bioyond | `bioyond/bottles.py` | `bioyond/bottle_carriers.py` | `bioyond/warehouses.py`, `YB_warehouses.py` | `bioyond/decks.py` |
-| battery | — | `battery/bottle_carriers.py` | — | — |
-| 通用 | — | — | `warehouse.py` | — |
-
-### 关键路径
-
-| 内容 | 路径 |
-|------|------|
-| Bottle/Carrier 基类 | `unilabos/resources/itemized_carrier.py` |
-| WareHouse 基类 + 工厂 | `unilabos/resources/warehouse.py` |
-| PLR 注册 | `unilabos/resources/plr_additional_res_reg.py` |
-| 资源注册表 | `unilabos/registry/resources/` |
-| 图文件加载 | `unilabos/resources/graphio.py` |
-| 资源跟踪器 | `unilabos/resources/resource_tracker.py` |

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

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

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

@@ -1,500 +0,0 @@
----
-name: add-workstation
-description: Guide for adding new workstations to Uni-Lab-OS (接入新工作站). Walks through workstation type selection, sub-device composition, external system integration, driver creation, registry YAML, deck setup, and graph file configuration. Use when the user wants to add/integrate a new workstation, create a workstation driver, configure a station with sub-devices, set up deck and materials, or mentions 工作站/工站/station/workstation.
----
-
-# Uni-Lab-OS 工作站接入指南
-
-工作站（workstation）是组合多个子设备的大型设备，拥有独立的物料管理系统（PLR Deck）和工作流引擎。本指南覆盖从需求分析到验证的全流程。
-
-> **前置知识**：工作站接入基于 `docs/ai_guides/add_device.md` 的通用设备接入框架，但有显著差异。阅读本指南前无需先读通用指南。
-
-## 第一步：确定工作站类型
-
-向用户确认以下信息：
-
-**Q1: 工作站的业务场景？**
-
-| 类型 | 基类 | 适用场景 | 示例 |
-|------|------|----------|------|
-| **Protocol 工作站** | `ProtocolNode` | 标准化学操作协议（过滤、转移、加热等） | FilterProtocolStation |
-| **外部系统工作站** | `WorkstationBase` | 与外部 LIMS/MES 系统对接，有专属 API | BioyondStation |
-| **硬件控制工作站** | `WorkstationBase` | 直接控制 PLC/硬件，无外部系统 | CoinCellAssembly |
-
-**Q2: 工作站英文名称？**（如 `my_reaction_station`）
-
-**Q3: 与外部系统的交互方式？**
-
-| 方式 | 适用场景 | 需要的配置 |
-|------|----------|-----------|
-| 无外部系统 | Protocol 工作站、纯硬件控制 | 无 |
-| HTTP API | LIMS/MES 系统（如 Bioyond） | `api_host`, `api_key` |
-| Modbus TCP | PLC 控制 | `address`, `port` |
-| OPC UA | 工业设备 | `url` |
-
-**Q4: 子设备组成？**
-- 列出所有子设备（如反应器、泵、阀、传感器等）
-- 哪些是已有设备类型？哪些需要新增？
-- 子设备之间的硬件代理关系（如泵通过串口设备通信）
-
-**Q5: 物料管理需求？**
-- 是否需要 Deck（物料面板）？
-- 物料类型（plate、tip_rack、bottle 等）
-- 是否需要与外部物料系统同步？
-
----
-
-## 第二步：理解工作站架构
-
-工作站与普通设备的核心差异：
-
-| 维度 | 普通设备 | 工作站 |
-|------|---------|--------|
-| 基类 | 无（纯 Python 类） | `WorkstationBase` 或 `ProtocolNode` |
-| ROS 节点 | `BaseROS2DeviceNode` | `ROS2WorkstationNode` |
-| 状态管理 | `self.data` 字典 | 通常不用 `self.data`，用 `@property` 直接访问 |
-| 子设备 | 无 | `children` 列表，通过 `self._children` 访问 |
-| 物料 | 无 | `self.deck`（PLR Deck） |
-| 图文件角色 | `parent: null` 或 `parent: "<station>"` | `parent: null`，含 `children` 和 `deck` |
-
-### 继承体系
-
-`WorkstationBase` (ABC) → `ProtocolNode` (通用协议) / `BioyondWorkstation` (→ ReactionStation, DispensingStation) / `CoinCellAssemblyWorkstation` (硬件控制)
-
-### ROS 层
-
-`ROS2WorkstationNode` 额外负责：初始化 children 子设备节点、为子设备创建 ActionClient、配置硬件代理、为 protocol_type 创建协议 ActionServer。
-
----
-
-## 第三步：创建驱动文件
-
-文件路径：`unilabos/devices/workstation/<station_name>/<station_name>.py`
-
-### 模板 A：基于外部系统的工作站
-
-适用于与 LIMS/MES 等外部系统对接的场景。
-
-```python
-import logging
-from typing import Dict, Any, Optional, List
-from pylabrobot.resources import Deck
-
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-
-try:
-    from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
-except ImportError:
-    ROS2WorkstationNode = None
-
-
-class MyWorkstation(WorkstationBase):
-    """工作站描述"""
-
-    _ros_node: "ROS2WorkstationNode"
-
-    def __init__(
-        self,
-        config: dict = None,
-        deck: Optional[Deck] = None,
-        protocol_type: list = None,
-        **kwargs,
-    ):
-        super().__init__(deck=deck, **kwargs)
-        self.config = config or {}
-        self.logger = logging.getLogger(f"MyWorkstation")
-
-        # 外部系统连接配置
-        self.api_host = self.config.get("api_host", "")
-        self.api_key = self.config.get("api_key", "")
-
-        # 工作站业务状态（不同于 self.data 模式）
-        self._status = "Idle"
-
-    def post_init(self, ros_node: "ROS2WorkstationNode") -> None:
-        super().post_init(ros_node)
-        # 在这里启动后台服务、连接监控等
-
-    # ============ 子设备访问 ============
-
-    def _get_child_device(self, device_id: str):
-        """通过 ID 获取子设备节点"""
-        return self._children.get(device_id)
-
-    # ============ 动作方法 ============
-
-    async def scheduler_start(self, **kwargs) -> Dict[str, Any]:
-        """启动调度器"""
-        return {"success": True}
-
-    async def create_order(self, json_str: str, **kwargs) -> Dict[str, Any]:
-        """创建工单"""
-        return {"success": True}
-
-    # ============ 属性 ============
-
-    @property
-    def workflow_sequence(self) -> str:
-        return "[]"
-
-    @property
-    def material_info(self) -> str:
-        return "{}"
-```
-
-### 模板 B：基于硬件控制的工作站
-
-适用于直接与 PLC/硬件通信的场景。
-
-```python
-import logging
-from typing import Dict, Any, Optional
-from pylabrobot.resources import Deck
-
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-
-try:
-    from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
-except ImportError:
-    ROS2WorkstationNode = None
-
-
-class MyHardwareWorkstation(WorkstationBase):
-    """硬件控制工作站"""
-
-    _ros_node: "ROS2WorkstationNode"
-
-    def __init__(
-        self,
-        config: dict = None,
-        deck: Optional[Deck] = None,
-        address: str = "192.168.1.100",
-        port: str = "502",
-        debug_mode: bool = False,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(deck=deck, *args, **kwargs)
-        self.config = config or {}
-        self.address = address
-        self.port = int(port)
-        self.debug_mode = debug_mode
-        self.logger = logging.getLogger("MyHardwareWorkstation")
-
-        # 初始化通信客户端
-        if not debug_mode:
-            from unilabos.device_comms.modbus_plc.client import ModbusTcpClient
-            self.client = ModbusTcpClient(host=self.address, port=self.port)
-        else:
-            self.client = None
-
-    def post_init(self, ros_node: "ROS2WorkstationNode") -> None:
-        super().post_init(ros_node)
-
-    # ============ 硬件读写 ============
-
-    def _read_register(self, name: str):
-        """读取 Modbus 寄存器"""
-        if self.debug_mode:
-            return 0
-        # 实际读取逻辑
-        pass
-
-    # ============ 动作方法 ============
-
-    async def start_process(self, **kwargs) -> Dict[str, Any]:
-        """启动加工流程"""
-        return {"success": True}
-
-    async def stop_process(self, **kwargs) -> Dict[str, Any]:
-        """停止加工流程"""
-        return {"success": True}
-
-    # ============ 属性（从硬件实时读取）============
-
-    @property
-    def sys_status(self) -> str:
-        return str(self._read_register("SYS_STATUS"))
-```
-
-### 模板 C：Protocol 工作站
-
-适用于标准化学操作协议的场景，直接使用 `ProtocolNode`。
-
-```python
-from typing import List, Optional
-from pylabrobot.resources import Resource as PLRResource
-
-from unilabos.devices.workstation.workstation_base import ProtocolNode
-
-
-class MyProtocolStation(ProtocolNode):
-    """Protocol 工作站 — 使用标准化学操作协议"""
-
-    def __init__(
-        self,
-        protocol_type: List[str],
-        deck: Optional[PLRResource] = None,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(protocol_type=protocol_type, deck=deck, *args, **kwargs)
-```
-
-> Protocol 工作站通常不需要自定义驱动类，直接使用 `ProtocolNode` 并在注册表和图文件中配置 `protocol_type` 即可。
-
----
-
-## 第四步：创建子设备驱动（如需要）
-
-工作站的子设备本身是独立设备。按 `docs/ai_guides/add_device.md` 的标准流程创建。
-
-子设备的关键约束：
-- 在图文件中 `parent` 指向工作站 ID
-- 图文件中在工作站的 `children` 数组里列出
-- 如需硬件代理，在子设备的 `config.hardware_interface.name` 指向通信设备 ID
-
----
-
-## 第五步：创建注册表 YAML
-
-路径：`unilabos/registry/devices/<station_name>.yaml`
-
-### 最小配置
-
-```yaml
-my_workstation:
-  category:
-    - workstation
-  class:
-    module: unilabos.devices.workstation.my_station.my_station:MyWorkstation
-    type: python
-```
-
-启动时 `--complete_registry` 自动补全 `status_types` 和 `action_value_mappings`。
-
-### 完整配置参考
-
-```yaml
-my_workstation:
-  description: "我的工作站"
-  version: "1.0.0"
-  category:
-    - workstation
-    - my_category
-  class:
-    module: unilabos.devices.workstation.my_station.my_station:MyWorkstation
-    type: python
-    status_types:
-      workflow_sequence: String
-      material_info: String
-    action_value_mappings:
-      scheduler_start:
-        type: UniLabJsonCommandAsync
-        goal: {}
-        result:
-          success: success
-      create_order:
-        type: UniLabJsonCommandAsync
-        goal:
-          json_str: json_str
-        result:
-          success: success
-  init_param_schema:
-    config:
-      type: object
-    deck:
-      type: object
-    protocol_type:
-      type: array
-```
-
-### 子设备注册表
-
-子设备有独立的注册表文件，需要在 `category` 中包含工作站标识：
-
-```yaml
-my_reactor:
-  category:
-    - reactor
-    - my_workstation
-  class:
-    module: unilabos.devices.workstation.my_station.my_reactor:MyReactor
-    type: python
-```
-
----
-
-## 第六步：配置 Deck 资源（如需要）
-
-如果工作站有物料管理需求，需要定义 Deck 类。
-
-### 使用已有 Deck 类
-
-查看 `unilabos/resources/` 目录下是否有适用的 Deck 类。
-
-### 创建自定义 Deck
-
-在 `unilabos/resources/<category>/decks.py` 中定义：
-
-```python
-from pylabrobot.resources import Deck
-from pylabrobot.resources.coordinate import Coordinate
-
-
-def MyStation_Deck(name: str = "MyStation_Deck") -> Deck:
-    deck = Deck(name=name, size_x=2700.0, size_y=1080.0, size_z=1500.0)
-    # 在 deck 上定义子资源位置（carrier、plate 等）
-    return deck
-```
-
-在 `unilabos/resources/<category>/` 下注册或通过注册表引用。
-
----
-
-## 第七步：配置图文件
-
-图文件路径：`unilabos/test/experiments/<station_name>.json`
-
-### 完整结构
-
-```json
-{
-    "nodes": [
-        {
-            "id": "my_station",
-            "name": "my_station",
-            "children": ["my_deck", "sub_device_1", "sub_device_2"],
-            "parent": null,
-            "type": "device",
-            "class": "my_workstation",
-            "position": {"x": 0, "y": 0, "z": 0},
-            "config": {
-                "api_host": "http://192.168.1.100:8080",
-                "api_key": "YOUR_KEY"
-            },
-            "deck": {
-                "data": {
-                    "_resource_child_name": "my_deck",
-                    "_resource_type": "unilabos.resources.my_module.decks:MyStation_Deck"
-                }
-            },
-            "size_x": 2700.0,
-            "size_y": 1080.0,
-            "size_z": 1500.0,
-            "protocol_type": [],
-            "data": {}
-        },
-        {
-            "id": "my_deck",
-            "name": "my_deck",
-            "children": [],
-            "parent": "my_station",
-            "type": "deck",
-            "class": "MyStation_Deck",
-            "position": {"x": 0, "y": 0, "z": 0},
-            "config": {
-                "type": "MyStation_Deck",
-                "setup": true,
-                "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"}
-            },
-            "data": {}
-        },
-        {
-            "id": "sub_device_1",
-            "name": "sub_device_1",
-            "children": [],
-            "parent": "my_station",
-            "type": "device",
-            "class": "sub_device_registry_name",
-            "position": {"x": 100, "y": 0, "z": 0},
-            "config": {},
-            "data": {}
-        }
-    ]
-}
-```
-
-### 图文件规则
-
-| 字段 | 说明 |
-|------|------|
-| `id` | 节点唯一标识，与 `children` 数组中的引用一致 |
-| `children` | 包含 deck ID 和所有子设备 ID |
-| `parent` | 工作站节点为 `null`；子设备/deck 指向工作站 ID |
-| `type` | 工作站和子设备为 `"device"`；deck 为 `"deck"` |
-| `class` | 对应注册表中的设备名 |
-| `deck.data._resource_child_name` | 必须与 deck 节点的 `id` 一致 |
-| `deck.data._resource_type` | Deck 工厂函数的完整 Python 路径 |
-| `protocol_type` | Protocol 工作站填入协议名列表；否则为 `[]` |
-| `config` | 传入驱动 `__init__` 的 `config` 参数 |
-
----
-
-## 第八步：验证
-
-```bash
-# 1. 模块可导入
-python -c "from unilabos.devices.workstation.<name>.<name> import <ClassName>"
-
-# 2. 注册表补全
-unilab -g <graph>.json --complete_registry
-
-# 3. 启动测试
-unilab -g <graph>.json
-```
-
----
-
-## 高级模式
-
-实现外部系统对接型工作站时，详见 [reference.md](reference.md)：RPC 客户端、HTTP 回调服务、连接监控、Config 结构模式（material_type_mappings / warehouse_mapping / workflow_mappings）、ResourceSynchronizer、update_resource、工作流序列、站间物料转移、post_init 完整模式。
-
----
-
-## 关键规则
-
-1. **`__init__` 必须接受 `deck` 和 `**kwargs`** — `WorkstationBase.__init__` 需要 `deck` 参数
-2. **通过 `self._children` 访问子设备** — 不要自行维护子设备引用
-3. **`post_init` 中启动后台服务** — 不要在 `__init__` 中启动网络连接
-4. **异步方法使用 `await self._ros_node.sleep()`** — 禁止 `time.sleep()` 和 `asyncio.sleep()`
-5. **子设备在图文件中声明** — 不在驱动代码中创建子设备实例
-6. **`deck` 配置中的 `_resource_child_name` 必须与 deck 节点 ID 一致**
-7. **Protocol 工作站优先使用 `ProtocolNode`** — 不需要自定义类
-
----
-
-## 工作流清单
-
-```
-工作站接入进度：
-- [ ] 1. 确定工作站类型（Protocol / 外部系统 / 硬件控制）
-- [ ] 2. 确认子设备组成和物料需求
-- [ ] 3. 创建工作站驱动 unilabos/devices/workstation/<name>/<name>.py
-- [ ] 4. 创建子设备驱动（如需要，按 add_device.md 流程）
-- [ ] 5. 创建注册表 unilabos/registry/devices/<name>.yaml
-- [ ] 6. 创建/选择 Deck 资源类（如需要）
-- [ ] 7. 配置图文件 unilabos/test/experiments/<name>.json
-- [ ] 8. 验证：可导入 + 注册表补全 + 启动测试
-```
-
----
-
-## 现有工作站参考
-
-| 工作站 | 注册表名 | 驱动类 | 类型 |
-|--------|----------|--------|------|
-| Protocol 通用 | `workstation` | `ProtocolNode` | Protocol |
-| Bioyond 反应站 | `reaction_station.bioyond` | `BioyondReactionStation` | 外部系统 |
-| Bioyond 配液站 | `bioyond_dispensing_station` | `BioyondDispensingStation` | 外部系统 |
-| 纽扣电池组装 | `coincellassemblyworkstation_device` | `CoinCellAssemblyWorkstation` | 硬件控制 |
-
-### 参考文件路径
-
-- 基类: `unilabos/devices/workstation/workstation_base.py`
-- Bioyond 基类: `unilabos/devices/workstation/bioyond_studio/station.py`
-- 反应站: `unilabos/devices/workstation/bioyond_studio/reaction_station/reaction_station.py`
-- 配液站: `unilabos/devices/workstation/bioyond_studio/dispensing_station/dispensing_station.py`
-- 纽扣电池: `unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`
-- ROS 节点: `unilabos/ros/nodes/presets/workstation.py`
-- 图文件: `unilabos/test/experiments/reaction_station_bioyond.json`, `dispensing_station_bioyond.json`

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

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

.cursor/skills/edit-experiment-graph/SKILL.md

@@ -1,381 +0,0 @@
----
-name: edit-experiment-graph
-description: Guide for creating and editing experiment graph files in Uni-Lab-OS (创建/编辑实验组态图). Covers node types, link types, parent-child relationships, deck configuration, and common graph patterns. Use when the user wants to create a graph file, edit an experiment configuration, set up device topology, or mentions 图文件/graph/组态/拓扑/实验图/experiment JSON.
----
-
-# 创建/编辑实验组态图
-
-实验图（Graph File）定义设备拓扑、物理连接和物料配置。系统启动时加载图文件，初始化所有设备和连接关系。
-
-路径：`unilabos/test/experiments/<name>.json`
-
----
-
-## 第一步：确认需求
-
-向用户确认：
-
-| 信息 | 说明 |
-|------|------|
-| 场景类型 | 单设备调试 / 多设备联调 / 工作站完整图 |
-| 包含的设备 | 设备 ID、注册表 class 名、配置参数 |
-| 连接关系 | 物理连接（管道）/ 通信连接（串口）/ 无连接 |
-| 父子关系 | 是否有工作站包含子设备 |
-| 物料需求 | 是否需要 Deck、容器、试剂瓶 |
-
----
-
-## 第二步：JSON 顶层结构
-
-```json
-{
-    "nodes": [],
-    "links": []
-}
-```
-
-> `links` 也可写作 `edges`，加载时两者等效。
-
----
-
-## 第三步：定义 Nodes
-
-### 节点字段
-
-| 字段 | 类型 | 必需 | 默认值 | 说明 |
-|------|------|------|--------|------|
-| `id` | string | **是** | — | 节点唯一标识，links 和 children 中引用此值 |
-| `class` | string | **是** | — | 对应注册表名（设备/资源 YAML 的 key），容器可为 `null` |
-| `name` | string | 否 | 同 `id` | 显示名称，缺省时自动用 `id` |
-| `type` | string | 否 | `"device"` | 节点类型（见下表），缺省时自动设为 `"device"` |
-| `children` | string[] | 否 | `[]` | 子节点 ID 列表 |
-| `parent` | string\|null | 否 | `null` | 父节点 ID，顶层设备为 `null` |
-| `position` | object | 否 | `{x:0,y:0,z:0}` | 空间坐标 |
-| `config` | object | 否 | `{}` | 传给驱动 `__init__` 的参数 |
-| `data` | object | 否 | `{}` | 初始运行状态 |
-| `size_x/y/z` | float | 否 | — | 节点物理尺寸（工作站节点常用） |
-
-> 非标准字段（如 `api_host`）会自动移入 `config`。
-
-### 节点类型
-
-| `type` | 用途 | `class` 要求 |
-|--------|------|-------------|
-| `device` | 设备（默认） | 注册表中的设备名 |
-| `deck` | 工作台面 | Deck 工厂函数/类名 |
-| `container` | 容器（烧瓶、反应釜） | `null` 或具体容器类名 |
-
-### 设备节点模板
-
-```json
-{
-    "id": "my_device",
-    "name": "我的设备",
-    "children": [],
-    "parent": null,
-    "type": "device",
-    "class": "registry_device_name",
-    "position": {"x": 0, "y": 0, "z": 0},
-    "config": {
-        "port": "/dev/ttyUSB0",
-        "baudrate": 115200
-    },
-    "data": {
-        "status": "Idle"
-    }
-}
-```
-
-### 容器节点模板
-
-容器用于协议系统中表示试剂瓶、反应釜等，`class` 通常为 `null`：
-
-```json
-{
-    "id": "flask_DMF",
-    "name": "DMF试剂瓶",
-    "children": [],
-    "parent": "my_station",
-    "type": "container",
-    "class": null,
-    "position": {"x": 200, "y": 500, "z": 0},
-    "config": {"max_volume": 1000.0},
-    "data": {
-        "liquid": [{"liquid_type": "DMF", "liquid_volume": 800.0}]
-    }
-}
-```
-
-### Deck 节点模板
-
-```json
-{
-    "id": "my_deck",
-    "name": "my_deck",
-    "children": [],
-    "parent": "my_station",
-    "type": "deck",
-    "class": "MyStation_Deck",
-    "position": {"x": 0, "y": 0, "z": 0},
-    "config": {
-        "type": "MyStation_Deck",
-        "setup": true,
-        "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"}
-    },
-    "data": {}
-}
-```
-
----
-
-## 第四步：定义 Links
-
-### Link 字段
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `source` | string | 源节点 ID |
-| `target` | string | 目标节点 ID |
-| `type` | string | `"physical"` / `"fluid"` / `"communication"` |
-| `port` | object | 端口映射 `{source_id: "port_name", target_id: "port_name"}` |
-
-### 物理/流体连接
-
-设备间的管道连接，协议系统用此查找路径：
-
-```json
-{
-    "source": "multiway_valve_1",
-    "target": "flask_DMF",
-    "type": "fluid",
-    "port": {
-        "multiway_valve_1": "2",
-        "flask_DMF": "outlet"
-    }
-}
-```
-
-### 通信连接
-
-设备间的串口/IO 通信代理，加载时自动将端口信息写入目标设备 config：
-
-```json
-{
-    "source": "pump_1",
-    "target": "serial_device",
-    "type": "communication",
-    "port": {
-        "pump_1": "port",
-        "serial_device": "port"
-    }
-}
-```
-
----
-
-## 第五步：父子关系与工作站配置
-
-### 工作站 + 子设备
-
-工作站节点的 `children` 列出所有子节点 ID，子节点的 `parent` 指向工作站：
-
-```json
-{
-    "id": "my_station",
-    "children": ["my_deck", "pump_1", "valve_1", "reactor_1"],
-    "parent": null,
-    "type": "device",
-    "class": "workstation",
-    "config": {
-        "protocol_type": ["PumpTransferProtocol", "CleanProtocol"]
-    }
-}
-```
-
-### 工作站 + Deck 引用
-
-工作站节点中通过 `deck` 字段引用 Deck：
-
-```json
-{
-    "id": "my_station",
-    "children": ["my_deck", "sub_device_1"],
-    "deck": {
-        "data": {
-            "_resource_child_name": "my_deck",
-            "_resource_type": "unilabos.resources.my_module.decks:MyDeck"
-        }
-    }
-}
-```
-
-**关键约束：**
-- `_resource_child_name` 必须与 Deck 节点的 `id` 一致
-- `_resource_type` 为 Deck 类/工厂函数的完整 Python 路径
-
----
-
-## 常见图模式
-
-### 模式 A：单设备调试
-
-最简形式，一个设备节点，无连接：
-
-```json
-{
-    "nodes": [
-        {
-            "id": "my_device",
-            "name": "my_device",
-            "children": [],
-            "parent": null,
-            "type": "device",
-            "class": "motor.zdt_x42",
-            "position": {"x": 0, "y": 0, "z": 0},
-            "config": {"port": "/dev/ttyUSB0", "baudrate": 115200},
-            "data": {"status": "idle"}
-        }
-    ],
-    "links": []
-}
-```
-
-### 模式 B：Protocol 工作站（泵+阀+容器）
-
-工作站配合泵、阀、容器和物理连接，用于协议编译：
-
-```json
-{
-    "nodes": [
-        {
-            "id": "station", "name": "协议工作站",
-            "class": "workstation", "type": "device", "parent": null,
-            "children": ["pump", "valve", "flask_solvent", "reactor", "waste"],
-            "config": {"protocol_type": ["PumpTransferProtocol"]}
-        },
-        {"id": "pump", "name": "转移泵", "class": "virtual_transfer_pump",
-         "type": "device", "parent": "station",
-         "config": {"port": "VIRTUAL", "max_volume": 25.0},
-         "data": {"status": "Idle", "position": 0.0, "valve_position": "0"}},
-        {"id": "valve", "name": "多通阀", "class": "virtual_multiway_valve",
-         "type": "device", "parent": "station",
-         "config": {"port": "VIRTUAL", "positions": 8}},
-        {"id": "flask_solvent", "name": "溶剂瓶", "type": "container",
-         "class": null, "parent": "station",
-         "config": {"max_volume": 1000.0},
-         "data": {"liquid": [{"liquid_type": "DMF", "liquid_volume": 500}]}},
-        {"id": "reactor", "name": "反应器", "type": "container",
-         "class": null, "parent": "station"},
-        {"id": "waste", "name": "废液瓶", "type": "container",
-         "class": null, "parent": "station"}
-    ],
-    "links": [
-        {"source": "pump", "target": "valve", "type": "fluid",
-         "port": {"pump": "transferpump", "valve": "transferpump"}},
-        {"source": "valve", "target": "flask_solvent", "type": "fluid",
-         "port": {"valve": "1", "flask_solvent": "outlet"}},
-        {"source": "valve", "target": "reactor", "type": "fluid",
-         "port": {"valve": "2", "reactor": "inlet"}},
-        {"source": "valve", "target": "waste", "type": "fluid",
-         "port": {"valve": "3", "waste": "inlet"}}
-    ]
-}
-```
-
-### 模式 C：外部系统工作站 + Deck
-
-```json
-{
-    "nodes": [
-        {
-            "id": "bioyond_station", "class": "reaction_station.bioyond",
-            "parent": null, "children": ["bioyond_deck"],
-            "config": {
-                "api_host": "http://192.168.1.100:8080",
-                "api_key": "YOUR_KEY",
-                "material_type_mappings": {},
-                "warehouse_mapping": {}
-            },
-            "deck": {
-                "data": {
-                    "_resource_child_name": "bioyond_deck",
-                    "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
-                }
-            }
-        },
-        {
-            "id": "bioyond_deck", "class": "BIOYOND_PolymerReactionStation_Deck",
-            "parent": "bioyond_station", "type": "deck",
-            "config": {"type": "BIOYOND_PolymerReactionStation_Deck", "setup": true}
-        }
-    ],
-    "links": []
-}
-```
-
-### 模式 D：通信代理（串口设备）
-
-泵通过串口设备通信，使用 `communication` 类型的 link。加载时系统会自动将串口端口信息写入泵的 `config`：
-
-```json
-{
-    "nodes": [
-        {"id": "station", "name": "工作站", "type": "device",
-         "class": "workstation", "parent": null,
-         "children": ["serial_1", "pump_1"]},
-        {"id": "serial_1", "name": "串口", "type": "device",
-         "class": "serial", "parent": "station",
-         "config": {"port": "COM7", "baudrate": 9600}},
-        {"id": "pump_1", "name": "注射泵", "type": "device",
-         "class": "syringe_pump_with_valve.runze.SY03B-T08", "parent": "station"}
-    ],
-    "links": [
-        {"source": "pump_1", "target": "serial_1", "type": "communication",
-         "port": {"pump_1": "port", "serial_1": "port"}}
-    ]
-}
-```
-
----
-
-## 验证
-
-```bash
-# 启动测试
-unilab -g unilabos/test/experiments/<name>.json --complete_registry
-
-# 仅检查注册表
-python -m unilabos --check_mode --skip_env_check
-```
-
----
-
-## 高级模式
-
-处理复杂图文件时，详见 [reference.md](reference.md)：ResourceDict 完整字段 schema、Pose 标准化规则、Handle 验证机制、GraphML 格式支持、外部系统工作站完整 config 结构。
-
----
-
-## 常见错误
-
-| 错误 | 原因 | 修复 |
-|------|------|------|
-| `class` 找不到 | 注册表中无此设备名 | 在 `unilabos/registry/devices/` 或 `resources/` 中搜索正确名称 |
-| children/parent 不一致 | 子节点 `parent` 与父节点 `children` 不匹配 | 确保双向一致 |
-| `_resource_child_name` 不匹配 | Deck 引用名与 Deck 节点 `id` 不同 | 保持一致 |
-| Link 端口错误 | `port` 中的 key 不是 source/target 的 `id` | key 必须是对应节点的 `id` |
-| 重复 UUID | 多个节点有相同 `uuid` | 删除或修改 UUID |
-
----
-
-## 参考路径
-
-| 内容 | 路径 |
-|------|------|
-| 图文件目录 | `unilabos/test/experiments/` |
-| 协议测试站 | `unilabos/test/experiments/Protocol_Test_Station/` |
-| 图加载代码 | `unilabos/resources/graphio.py` |
-| 节点模型 | `unilabos/resources/resource_tracker.py` |
-| 设备注册表 | `unilabos/registry/devices/` |
-| 资源注册表 | `unilabos/registry/resources/` |
-| 用户文档 | `docs/user_guide/graph_files.md` |

.cursor/skills/edit-experiment-graph/reference.md

@@ -1,255 +0,0 @@
-# 实验图高级参考
-
-本文件是 SKILL.md 的补充，包含 ResourceDict 完整 schema、Handle 验证、GraphML 格式、Pose 标准化规则和复杂图文件结构。Agent 在需要处理这些场景时按需阅读。
-
----
-
-## 1. ResourceDict 完整字段
-
-`unilabos/resources/resource_tracker.py` 中定义的节点数据模型：
-
-| 字段 | 类型 | 别名 | 说明 |
-|------|------|------|------|
-| `id` | `str` | — | 节点唯一标识 |
-| `uuid` | `str` | — | 全局唯一标识 |
-| `name` | `str` | — | 显示名称 |
-| `description` | `str` | — | 描述（默认 `""` ） |
-| `resource_schema` | `Dict[str, Any]` | `schema` | 资源 schema |
-| `model` | `Dict[str, Any]` | — | 3D 模型信息 |
-| `icon` | `str` | — | 图标（默认 `""` ） |
-| `parent_uuid` | `Optional[str]` | — | 父节点 UUID |
-| `parent` | `Optional[ResourceDict]` | — | 父节点引用（序列化时 exclude） |
-| `type` | `Union[Literal["device"], str]` | — | 节点类型 |
-| `klass` | `str` | `class` | 注册表类名 |
-| `pose` | `ResourceDictPosition` | — | 位姿信息 |
-| `config` | `Dict[str, Any]` | — | 配置参数 |
-| `data` | `Dict[str, Any]` | — | 运行时数据 |
-| `extra` | `Dict[str, Any]` | — | 扩展数据 |
-
-### Pose 完整结构（ResourceDictPosition）
-
-| 字段 | 类型 | 默认值 | 说明 |
-|------|------|--------|------|
-| `size` | `{width, height, depth}` | `{0,0,0}` | 节点尺寸 |
-| `scale` | `{x, y, z}` | `{1,1,1}` | 缩放比例 |
-| `layout` | `"2d"/"x-y"/"z-y"/"x-z"` | `"x-y"` | 布局方向 |
-| `position` | `{x, y, z}` | `{0,0,0}` | 2D 位置 |
-| `position3d` | `{x, y, z}` | `{0,0,0}` | 3D 位置 |
-| `rotation` | `{x, y, z}` | `{0,0,0}` | 旋转角度 |
-| `cross_section_type` | `"rectangle"/"circle"/"rounded_rectangle"` | `"rectangle"` | 横截面形状 |
-
----
-
-## 2. Position / Pose 标准化规则
-
-图文件中的 `position` 有多种写法，加载时自动标准化。
-
-### 输入格式兼容
-
-```json
-// 格式 A: 直接 {x, y, z}（最常用）
-"position": {"x": 100, "y": 200, "z": 0}
-
-// 格式 B: 嵌套 position
-"position": {"position": {"x": 100, "y": 200, "z": 0}}
-
-// 格式 C: 使用 pose 字段
-"pose": {"position": {"x": 100, "y": 200, "z": 0}}
-
-// 格式 D: 顶层 x, y, z（无 position 字段）
-"x": 100, "y": 200, "z": 0
-```
-
-### 标准化流程
-
-1. **graphio.py `canonicalize_nodes_data`**：若 `position` 不是 dict，从节点顶层提取 `x/y/z` 填入 `pose.position`
-2. **resource_tracker.py `get_resource_instance_from_dict`**：若 `position.x` 存在（旧格式），转为 `{"position": {"x":..., "y":..., "z":...}}`
-3. `pose.size` 从 `config.size_x/size_y/size_z` 自动填充
-
----
-
-## 3. Handle 验证
-
-启动时系统验证 link 中的 `sourceHandle` / `targetHandle` 是否在注册表的 `handles` 中定义。
-
-```python
-# unilabos/app/main.py (约 449-481 行)
-source_handler_keys = [
-    h["handler_key"] for h in materials[source_node.klass]["handles"]
-    if h["io_type"] == "source"
-]
-target_handler_keys = [
-    h["handler_key"] for h in materials[target_node.klass]["handles"]
-    if h["io_type"] == "target"
-]
-if source_handle not in source_handler_keys:
-    print_status(f"节点 {source_node.id} 的source端点 {source_handle} 不存在", "error")
-    resource_edge_info.pop(...)  # 移除非法 link
-```
-
-**Handle 定义在注册表 YAML 中：**
-
-```yaml
-my_device:
-  handles:
-  - handler_key: access
-    io_type: target
-    data_type: fluid
-    side: NORTH
-    label: access
-```
-
-> 大多数简单设备不定义 handles，此验证仅对有 `sourceHandle`/`targetHandle` 的 link 生效。
-
----
-
-## 4. GraphML 格式支持
-
-除 JSON 外，系统也支持 GraphML 格式（`unilabos/resources/graphio.py::read_graphml`）。
-
-### 与 JSON 的关键差异
-
-| 特性 | JSON | GraphML |
-|------|------|---------|
-| 父子关系 | `parent`/`children` 字段 | `::` 分隔的节点 ID（如 `station::pump_1`） |
-| 加载后 | 直接解析 | 先 `nx.read_graphml` 再转 JSON 格式 |
-| 输出 | 不生成副本 | 自动生成等价的 `.json` 文件 |
-
-### GraphML 转换流程
-
-```
-nx.read_graphml(file)
-    ↓ 用 label 重映射节点名
-    ↓ 从 "::" 推断 parent_relation
-nx.relabel_nodes + nx.node_link_data
-    ↓ canonicalize_nodes_data + canonicalize_links_ports
-    ↓ 写出等价 JSON 文件
-physical_setup_graph + handle_communications
-```
-
----
-
-## 5. 复杂图文件结构示例
-
-### 外部系统工作站完整 config
-
-以 `reaction_station_bioyond.json` 为例，工作站 `config` 中的关键字段：
-
-```json
-{
-    "config": {
-        "api_key": "DE9BDDA0",
-        "api_host": "http://172.21.103.36:45388",
-
-        "workflow_mappings": {
-            "scheduler_start": {"workflow": "start", "params": {}},
-            "create_order": {"workflow": "create_order", "params": {}}
-        },
-
-        "material_type_mappings": {
-            "BIOYOND_PolymerStation_Reactor": ["反应器", "type-uuid-here"],
-            "BIOYOND_PolymerStation_1BottleCarrier": ["试剂瓶", "type-uuid-here"]
-        },
-
-        "warehouse_mapping": {
-            "堆栈1左": {
-                "uuid": "warehouse-uuid-here",
-                "site_uuids": {
-                    "A01": "site-uuid-1",
-                    "A02": "site-uuid-2"
-                }
-            }
-        },
-
-        "http_service_config": {
-            "enabled": true,
-            "host": "0.0.0.0",
-            "port": 45399,
-            "routes": ["/callback/workflow", "/callback/material"]
-        },
-
-        "deck": {
-            "data": {
-                "_resource_child_name": "Bioyond_Deck",
-                "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
-            }
-        },
-
-        "size_x": 2700.0,
-        "size_y": 1080.0,
-        "size_z": 2500.0,
-        "protocol_type": [],
-        "data": {}
-    }
-}
-```
-
-### 子设备 Reactor 节点
-
-```json
-{
-    "id": "reactor_1",
-    "name": "reactor_1",
-    "parent": "reaction_station_bioyond",
-    "type": "device",
-    "class": "bioyond_reactor",
-    "position": {"x": 1150, "y": 300, "z": 0},
-    "config": {
-        "reactor_index": 0,
-        "bioyond_workflow_key": "reactor_1"
-    },
-    "data": {}
-}
-```
-
-### Deck 节点
-
-```json
-{
-    "id": "Bioyond_Deck",
-    "name": "Bioyond_Deck",
-    "parent": "reaction_station_bioyond",
-    "type": "deck",
-    "class": "BIOYOND_PolymerReactionStation_Deck",
-    "position": {"x": 0, "y": 0, "z": 0},
-    "config": {
-        "type": "BIOYOND_PolymerReactionStation_Deck",
-        "setup": true,
-        "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"}
-    },
-    "data": {}
-}
-```
-
----
-
-## 6. Link 端口标准化
-
-`graphio.py::canonicalize_links_ports` 处理 `port` 字段的多种格式：
-
-```python
-# 输入: 字符串格式 "(A,B)"
-"port": "(pump_1, valve_1)"
-# 输出: 字典格式
-"port": {"source_id": "pump_1", "target_id": "valve_1"}
-
-# 输入: 已是字典
-"port": {"pump_1": "port", "serial_1": "port"}
-# 保持不变
-
-# 输入: 无 port 字段
-# 自动补充空 port
-```
-
----
-
-## 7. 关键路径
-
-| 内容 | 路径 |
-|------|------|
-| ResourceDict 模型 | `unilabos/resources/resource_tracker.py` |
-| 图加载 + 标准化 | `unilabos/resources/graphio.py` |
-| Handle 验证 | `unilabos/app/main.py` (449-481 行) |
-| 反应站图文件 | `unilabos/test/experiments/reaction_station_bioyond.json` |
-| 配液站图文件 | `unilabos/test/experiments/dispensing_station_bioyond.json` |
-| 用户文档 | `docs/user_guide/graph_files.md` |

.cursorignore

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

.github/copilot-instructions.md

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

.github/dependabot.yml

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

.github/workflows/ci-check.yml

@@ -1,67 +0,0 @@
-name: CI Check
-
-on:
-  push:
-    branches: [main, dev]
-  pull_request:
-    branches: [main, dev]
-
-jobs:
-  registry-check:
-    runs-on: windows-latest
-
-    env:
-      # Fix Unicode encoding issue on Windows runner (cp1252 -> utf-8)
-      PYTHONIOENCODING: utf-8
-      PYTHONUTF8: 1
-
-    defaults:
-      run:
-        shell: cmd
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Setup Miniforge
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-          miniforge-version: latest
-          use-mamba: true
-          channels: robostack-staging,conda-forge,uni-lab
-          channel-priority: flexible
-          activate-environment: check-env
-          auto-update-conda: false
-          show-channel-urls: true
-
-      - name: Install ROS dependencies, uv and unilabos-msgs
-        run: |
-          echo Installing ROS dependencies...
-          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: |
-          call conda activate check-env
-          echo Installing pip dependencies...
-          uv pip install -r unilabos/utils/requirements.txt
-          uv pip install pywinauto git+https://github.com/Xuwznln/pylabrobot.git
-          uv pip uninstall enum34 || echo enum34 not installed, skipping
-          uv pip install .
-
-      - name: Run check mode (complete_registry)
-        run: |
-          call conda activate check-env
-          echo Running check mode...
-          python -m unilabos --check_mode --skip_env_check
-
-      - name: Check for uncommitted changes
-        shell: bash
-        run: |
-          if ! git diff --exit-code; then
-            echo "::error::检测到文件变化！请先在本地运行 'python -m unilabos --complete_registry' 并提交变更"
-            echo "变化的文件:"
-            git diff --name-only
-            exit 1
-          fi
-          echo "检查通过：无文件变化"

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

@@ -13,11 +13,6 @@ on:
         required: false
         default: 'win-64'
         type: string
-      build_full:
-        description: '是否构建完整版 unilabos-full (默认构建轻量版 unilabos)'
-        required: false
-        default: false
-        type: boolean
 
 jobs:
   build-conda-pack:
@@ -62,7 +57,7 @@ jobs:
             echo "should_build=false" >> $GITHUB_OUTPUT
           fi
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         if: steps.should_build.outputs.should_build == 'true'
         with:
           ref: ${{ github.event.inputs.branch }}
@@ -74,7 +69,7 @@ jobs:
         with:
           miniforge-version: latest
           use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
           channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
@@ -86,14 +81,7 @@ jobs:
         run: |
           echo Installing unilabos and dependencies to unilab environment...
           echo Using mamba for faster and more reliable dependency resolution...
-          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 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 uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -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)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
@@ -101,14 +89,7 @@ jobs:
         run: |
           echo "Installing unilabos and dependencies to unilab environment..."
           echo "Using mamba for faster and more reliable dependency resolution..."
-          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 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 uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-          fi
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
 
       - name: Get latest ros-humble-unilabos-msgs version (Windows)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
@@ -312,7 +293,7 @@ jobs:
 
       - name: Upload distribution package
         if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
           path: dist-package/
@@ -327,12 +308,7 @@ jobs:
           echo ==========================================
           echo Platform: ${{ matrix.platform }}
           echo Branch: ${{ github.event.inputs.branch }}
-          echo Python version: 3.11.14
-          if "${{ github.event.inputs.build_full }}"=="true" (
-            echo Package: unilabos-full ^(complete^)
-          ) else (
-            echo Package: unilabos ^(minimal^)
-          )
+          echo Python version: 3.11.11
           echo.
           echo Distribution package contents:
           dir dist-package
@@ -352,12 +328,7 @@ jobs:
           echo "=========================================="
           echo "Platform: ${{ matrix.platform }}"
           echo "Branch: ${{ github.event.inputs.branch }}"
-          echo "Python version: 3.11.14"
-          if [[ "${{ github.event.inputs.build_full }}" == "true" ]]; then
-            echo "Package: unilabos-full (complete)"
-          else
-            echo "Package: unilabos (minimal)"
-          fi
+          echo "Python version: 3.11.11"
           echo ""
           echo "Distribution package contents:"
           ls -lh dist-package/

.github/workflows/deploy-docs.yml

@@ -1,12 +1,10 @@
 name: Deploy Docs
 
 on:
-  # 在 CI Check 成功后自动触发（仅 main 分支）
-  workflow_run:
-    workflows: ["CI Check"]
-    types: [completed]
+  push:
+    branches: [main]
+  pull_request:
     branches: [main]
-  # 手动触发
   workflow_dispatch:
     inputs:
       branch:
@@ -35,19 +33,12 @@ concurrency:
 jobs:
   # Build documentation
   build:
-    # 只在以下情况运行：
-    # 1. workflow_run 触发且 CI Check 成功
-    # 2. 手动触发
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
-          # workflow_run 时使用触发工作流的分支，手动触发时使用输入的分支
-          ref: ${{ github.event.workflow_run.head_branch || github.event.inputs.branch || github.ref }}
+          ref: ${{ github.event.inputs.branch || github.ref }}
           fetch-depth: 0
 
       - name: Setup Miniforge (with mamba)
@@ -55,7 +46,7 @@ jobs:
         with:
           miniforge-version: latest
           use-mamba: true
-          python-version: '3.11.14'
+          python-version: '3.11.11'
           channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: flexible
           activate-environment: unilab
@@ -84,10 +75,8 @@ jobs:
 
       - name: Setup Pages
         id: pages
-        uses: actions/configure-pages@v5
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/configure-pages@v4
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
 
       - name: Build Sphinx documentation
         run: |
@@ -105,18 +94,14 @@ jobs:
           test -f docs/_build/html/index.html && echo "✓ index.html exists" || echo "✗ index.html missing"
 
       - name: Upload build artifacts
-        uses: actions/upload-pages-artifact@v4
-        if: |
-          github.event.workflow_run.head_branch == 'main' ||
-          (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+        uses: actions/upload-pages-artifact@v3
+        if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
         with:
           path: docs/_build/html
 
   # Deploy to GitHub Pages
   deploy:
-    if: |
-      github.event.workflow_run.head_branch == 'main' ||
-      (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
+    if: github.ref == 'refs/heads/main' || (github.event_name == 'workflow_dispatch' && github.event.inputs.deploy_to_pages == 'true')
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

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

@@ -1,16 +1,11 @@
 name: Multi-Platform Conda Build
 
 on:
-  # 在 CI Check 工作流完成后触发（仅限 main/dev 分支）
-  workflow_run:
-    workflows: ["CI Check"]
-    types:
-      - completed
-    branches: [main, dev]
-  # 支持 tag 推送（不依赖 CI Check）
   push:
+    branches: [main, dev]
     tags: ['v*']
-  # 手动触发
+  pull_request:
+    branches: [main, dev]
   workflow_dispatch:
     inputs:
       platforms:
@@ -22,37 +17,9 @@ on:
         required: false
         default: false
         type: boolean
-      skip_ci_check:
-        description: '跳过等待 CI Check (手动触发时可选)'
-        required: false
-        default: false
-        type: boolean
 
 jobs:
-  # 等待 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 CI status
-        id: check
-        run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
-            echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "CI Check passed, proceeding with build"
-          else
-            echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
-          fi
-
   build:
-    needs: [wait-for-ci]
-    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
-    if: |
-      always() &&
-      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
     strategy:
       fail-fast: false
       matrix:
@@ -77,10 +44,8 @@ jobs:
         shell: bash -l {0}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
-          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
       - name: Check if platform should be built
@@ -104,6 +69,7 @@ jobs:
           channels: conda-forge,robostack-staging,defaults
           channel-priority: strict
           activate-environment: build-env
+          auto-activate-base: false
           auto-update-conda: false
           show-channel-urls: true
 
@@ -149,7 +115,7 @@ jobs:
 
       - name: Upload conda package artifacts
         if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: conda-package-${{ matrix.platform }}
           path: conda-packages-temp

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

@@ -1,62 +1,25 @@
 name: UniLabOS Conda Build
 
 on:
-  # 在 CI Check 成功后自动触发
-  workflow_run:
-    workflows: ["CI Check"]
-    types: [completed]
-    branches: [main, dev]
-  # 标签推送时直接触发（发布版本）
   push:
+    branches: [main, dev]
     tags: ['v*']
-  # 手动触发
+  pull_request:
+    branches: [main, dev]
   workflow_dispatch:
     inputs:
       platforms:
         description: '选择构建平台 (逗号分隔): linux-64, osx-64, osx-arm64, win-64'
         required: false
         default: 'linux-64'
-      build_full:
-        description: '是否构建 unilabos-full 完整包 (默认只构建 unilabos 基础包)'
-        required: false
-        default: false
-        type: boolean
       upload_to_anaconda:
         description: '是否上传到Anaconda.org'
         required: false
         default: false
         type: boolean
-      skip_ci_check:
-        description: '跳过等待 CI Check (手动触发时可选)'
-        required: false
-        default: false
-        type: boolean
 
 jobs:
-  # 等待 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 CI status
-        id: check
-        run: |
-          if [[ "${{ github.event.workflow_run.conclusion }}" == "success" ]]; then
-            echo "should_continue=true" >> $GITHUB_OUTPUT
-            echo "CI Check passed, proceeding with build"
-          else
-            echo "should_continue=false" >> $GITHUB_OUTPUT
-            echo "CI Check did not succeed (status: ${{ github.event.workflow_run.conclusion }}), skipping build"
-          fi
-
   build:
-    needs: [wait-for-ci]
-    # 运行条件：workflow_run 触发且 CI 成功，或者其他触发方式
-    if: |
-      always() &&
-      (needs.wait-for-ci.result == 'skipped' || needs.wait-for-ci.outputs.should_continue == 'true')
     strategy:
       fail-fast: false
       matrix:
@@ -77,10 +40,8 @@ jobs:
         shell: bash -l {0}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
-          # 如果是 workflow_run 触发，使用触发 CI Check 的 commit
-          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
           fetch-depth: 0
 
       - name: Check if platform should be built
@@ -104,6 +65,7 @@ jobs:
           channels: conda-forge,robostack-staging,uni-lab,defaults
           channel-priority: strict
           activate-environment: build-env
+          auto-activate-base: false
           auto-update-conda: false
           show-channel-urls: true
 
@@ -119,61 +81,12 @@ jobs:
           conda list | grep -E "(rattler-build|anaconda-client)"
           echo "Platform: ${{ matrix.platform }}"
           echo "OS: ${{ matrix.os }}"
-          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.inputs.build_full }}" == "true" ]]; then
-            echo "  - unilabos-full (complete package)"
-          fi
+          echo "Building UniLabOS package"
 
-      - name: Build unilabos-env (conda environment only, noarch)
+      - name: Build conda package
         if: steps.should_build.outputs.should_build == 'true'
         run: |
-          echo "Building unilabos-env (conda environment dependencies)..."
-          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.inputs.upload_to_anaconda == 'true'
-        run: |
-          echo "Uploading unilabos-env to uni-lab organization..."
-          for package in $(find ./output -name "unilabos-env*.conda"); do
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
-
-      - name: Build unilabos (with pip package)
-        if: steps.should_build.outputs.should_build == 'true'
-        run: |
-          echo "Building unilabos package..."
-          # 如果已上传到 Anaconda，从 uni-lab channel 获取 unilabos-env；否则从本地 output 获取
-          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.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
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
-
-      - name: Build unilabos-full - Only when explicitly requested
-        if: |
-          steps.should_build.outputs.should_build == 'true' && 
-          github.event.inputs.build_full == 'true'
-        run: |
-          echo "Building unilabos-full package on ${{ matrix.platform }}..."
-          rattler-build build -r .conda/full/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge --channel ./output
-
-      - name: Upload unilabos-full to Anaconda.org (if enabled)
-        if: |
-          steps.should_build.outputs.should_build == 'true' && 
-          github.event.inputs.build_full == 'true' &&
-          github.event.inputs.upload_to_anaconda == 'true'
-        run: |
-          echo "Uploading unilabos-full to uni-lab organization..."
-          for package in $(find ./output -name "unilabos-full*.conda"); do
-            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
-          done
+          rattler-build build -r .conda/recipe.yaml -c uni-lab -c robostack-staging -c conda-forge
 
       - name: List built packages
         if: steps.should_build.outputs.should_build == 'true'
@@ -195,9 +108,17 @@ jobs:
 
       - name: Upload conda package artifacts
         if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
         with:
           name: conda-package-unilabos-${{ matrix.platform }}
           path: conda-packages-temp
           if-no-files-found: warn
           retention-days: 30
+
+      - name: Upload to Anaconda.org (uni-lab organization)
+        if: github.event.inputs.upload_to_anaconda == 'true'
+        run: |
+          for package in $(find ./output -name "*.conda"); do
+            echo "Uploading $package to uni-lab organization..."
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+          done

.gitignore

@@ -4,7 +4,6 @@ temp/
 output/
 unilabos_data/
 pyrightconfig.json
-.cursorignore
 ## Python
 
 # Byte-compiled / optimized / DLL files

AGENTS.md

@@ -1,21 +0,0 @@
-# Uni-Lab-OS AI Agent 指南
-
-## 设备接入
-
-当用户要求添加/接入新设备时，读取 `docs/ai_guides/add_device.md` 并按其流程执行。
-该指南完全自包含，包含物模型模板、现有设备接口快照、常见错误和验证清单。
-
-## 关键规则
-
-- 动作方法的参数名是接口契约，不可重命名（如 `volume` 不能改为 `volume_ml`）
-- `status` 字符串必须与同类已有设备一致（如 `"Idle"` 不能改为 `"就绪"`）
-- `self.data` 必须在 `__init__` 中预填充所有属性字段
-- 异步方法中使用 `await self._ros_node.sleep()`，禁止 `time.sleep()` 和 `asyncio.sleep()`
-
-## 项目结构
-
-- 设备驱动：`unilabos/devices/<category>/<device_name>.py`
-- 设备注册表：`unilabos/registry/devices/<device_name>.yaml`
-- 实验图文件：`unilabos/test/experiments/*.json`
-- 人类开发文档：`docs/developer_guide/`
-- AI 专用指南：`docs/ai_guides/`

CLAUDE.md

@@ -1,14 +0,0 @@
-# Uni-Lab-OS
-
-## 设备接入
-
-读取 `docs/ai_guides/add_device.md` 获取完整的自包含指南。
-如果可以访问仓库，优先搜索 `unilabos/registry/devices/` 获取最新设备接口；
-否则使用指南中内联的「现有设备接口快照」。
-
-## 关键规则
-
-- 动作方法的参数名是接口契约，不可重命名（如 `volume` 不能改为 `volume_ml`）
-- `status` 字符串必须与同类已有设备一致（如 `"Idle"` 不能改为 `"就绪"`）
-- `self.data` 必须在 `__init__` 中预填充所有属性字段
-- 异步方法中使用 `await self._ros_node.sleep()`，禁止 `time.sleep()` 和 `asyncio.sleep()`

MANIFEST.in

@@ -1,5 +1,4 @@
 recursive-include unilabos/test *
-recursive-include unilabos/utils *
 recursive-include unilabos/registry *.yaml
 recursive-include unilabos/app/web/static *
 recursive-include unilabos/app/web/templates *

README.md

@@ -31,46 +31,26 @@ Detailed documentation can be found at:
 
 ## Quick Start
 
-### 1. Setup Conda Environment
+1. Setup Conda Environment
 
-Uni-Lab-OS recommends using `mamba` for environment management. Choose the package that fits your needs:
-
-| Package | Use Case | Contents |
-|---------|----------|----------|
-| `unilabos` | **Recommended for most users** | Complete package, ready to use |
-| `unilabos-env` | Developers (editable install) | Environment only, install unilabos via pip |
-| `unilabos-full` | Simulation/Visualization | unilabos + ROS2 Desktop + Gazebo + MoveIt |
+Uni-Lab-OS recommends using `mamba` for environment management:
 
 ```bash
 # Create new environment
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# Option A: Standard installation (recommended for most users)
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# Option B: For developers (editable mode development)
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# Then install unilabos and dependencies:
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# Option C: Full installation (simulation/visualization)
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-**When to use which?**
-- **unilabos**: Standard installation for production deployment and general usage (recommended)
-- **unilabos-env**: For developers who need `pip install -e .` editable mode, modify source code
-- **unilabos-full**: For simulation (Gazebo), visualization (rviz2), and Jupyter notebooks
-
-### 2. Clone Repository (Optional, for developers)
+2. Install Dev Uni-Lab-OS
 
 ```bash
-# Clone the repository (only needed for development or examples)
+# Clone the repository
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
+
+# Install Uni-Lab-OS
+pip install .
 ```
 
 3. Start Uni-Lab System

README_zh.md

@@ -31,46 +31,26 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控
 
 ## 快速开始
 
-### 1. 配置 Conda 环境
+1. 配置 Conda 环境
 
-Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的需求选择合适的安装包：
-
-| 安装包 | 适用场景 | 包含内容 |
-|--------|----------|----------|
-| `unilabos` | **推荐大多数用户** | 完整安装包，开箱即用 |
-| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
-| `unilabos-full` | 仿真/可视化 | unilabos + ROS2 桌面版 + Gazebo + MoveIt |
+Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适当的环境文件:
 
 ```bash
 # 创建新环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 mamba activate unilab
-
-# 方案 A：标准安装（推荐大多数用户）
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# 然后安装 unilabos 和依赖：
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# 方案 C：完整安装（仿真/可视化）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-**如何选择？**
-- **unilabos**：标准安装，适用于生产部署和日常使用（推荐）
-- **unilabos-env**：开发者使用，支持 `pip install -e .` 可编辑模式，可修改源代码
-- **unilabos-full**：需要仿真（Gazebo）、可视化（rviz2）或 Jupyter Notebook
-
-### 2. 克隆仓库（可选，供开发者使用）
+2. 安装开发版 Uni-Lab-OS:
 
 ```bash
-# 克隆仓库（仅开发或查看示例时需要）
+# 克隆仓库
 git clone https://github.com/deepmodeling/Uni-Lab-OS.git
 cd Uni-Lab-OS
+
+# 安装 Uni-Lab-OS
+pip install .
 ```
 
 3. 启动 Uni-Lab 系统

docs/ai_guides/agent_prompt_template.md

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

docs/user_guide/best_practice.md

@@ -31,14 +31,6 @@
 
 详细的安装步骤请参考 [安装指南](installation.md)。
 
-**选择合适的安装包：**
-
-| 安装包 | 适用场景 | 包含组件 |
-|--------|----------|----------|
-| `unilabos` | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 |
-| `unilabos-env` | 开发者（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos |
-| `unilabos-full` | 仿真/可视化 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt |
-
 **关键步骤：**
 
 ```bash
@@ -46,30 +38,15 @@
 # 下载 Miniforge: https://github.com/conda-forge/miniforge/releases
 
 # 2. 创建 Conda 环境
-mamba create -n unilab python=3.11.14
+mamba create -n unilab python=3.11.11
 
 # 3. 激活环境
 mamba activate unilab
 
-# 4. 安装 Uni-Lab-OS（选择其一）
-
-# 方案 A：标准安装（推荐大多数用户）
+# 4. 安装 Uni-Lab-OS
 mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-pip install -e /path/to/Uni-Lab-OS  # 可编辑安装
-uv pip install -r unilabos/utils/requirements.txt  # 安装 pip 依赖
-
-# 方案 C：完整版（仿真/可视化）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
 ```
 
-**选择建议：**
-- **日常使用/生产部署**：使用 `unilabos`（推荐），完整功能，开箱即用
-- **开发者**：使用 `unilabos-env` + `pip install -e .` + `uv pip install -r unilabos/utils/requirements.txt`，代码修改立即生效
-- **仿真/可视化**：使用 `unilabos-full`，含 Gazebo、rviz2、MoveIt
-
 #### 1.2 验证安装
 
 ```bash
@@ -439,9 +416,6 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 1. 访问 Web 界面，进入"仪器耗材"模块
 2. 在"仪器设备"区域找到并添加上述设备
 3. 在"物料耗材"区域找到并添加容器
-4. 在workstation中配置protocol_type包含PumpTransferProtocol
-
-![添加Protocol类型](image/add_protocol.png)
 
 ![物料列表](image/material.png)
 
@@ -452,9 +426,8 @@ unilab --ak your_ak --sk your_sk -g test/experiments/mock_devices/mock_all.json
 **操作步骤：**
 
 1. 将两个 `container` 拖拽到 `workstation` 中
-2. 将 `virtual_multiway_valve` 拖拽到 `workstation` 中
-3. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
-4. 在画布上连接它们（建立父子关系）
+2. 将 `virtual_transfer_pump` 拖拽到 `workstation` 中
+3. 在画布上连接它们（建立父子关系）
 
 ![设备连接](image/links.png)
 
@@ -795,43 +768,7 @@ Waiting for host service...
 
 详细的设备驱动编写指南请参考 [添加设备驱动](../developer_guide/add_device.md)。
 
-#### 9.1 开发环境准备
-
-**推荐使用 `unilabos-env` + `pip install -e .` + `uv pip install`** 进行设备开发：
-
-```bash
-# 1. 创建环境并安装 unilabos-env（ROS2 + conda 依赖 + uv）
-mamba create -n unilab python=3.11.14
-conda activate unilab
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-
-# 2. 克隆代码
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
-cd Uni-Lab-OS
-
-# 3. 以可编辑模式安装（推荐使用脚本，自动检测中文环境）
-python scripts/dev_install.py
-
-# 或手动安装：
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-```
-
-**为什么使用这种方式？**
-- `unilabos-env` 提供 ROS2 核心组件和 uv（通过 conda 安装，避免编译）
-- `unilabos/utils/requirements.txt` 包含所有运行时需要的 pip 依赖
-- `dev_install.py` 自动检测中文环境，中文系统自动使用清华镜像
-- 使用 `uv` 替代 `pip`，安装速度更快
-- 可编辑模式：代码修改**立即生效**，无需重新安装
-
-**如果安装失败或速度太慢**，可以手动执行（使用清华镜像）：
-
-```bash
-pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-```
-
-#### 9.2 为什么需要自定义设备？
+#### 9.1 为什么需要自定义设备？
 
 Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要集成：
 
@@ -840,7 +777,7 @@ Uni-Lab-OS 内置了常见设备，但您的实验室可能有特殊设备需要
 - 特殊的实验流程
 - 第三方设备集成
 
-#### 9.3 创建 Python 包
+#### 9.2 创建 Python 包
 
 为了方便开发和管理，建议为您的实验室创建独立的 Python 包。
 
@@ -877,7 +814,7 @@ touch my_lab_devices/my_lab_devices/__init__.py
 touch my_lab_devices/my_lab_devices/devices/__init__.py
 ```
 
-#### 9.4 创建 setup.py
+#### 9.3 创建 setup.py
 
 ```python
 # my_lab_devices/setup.py
@@ -908,7 +845,7 @@ setup(
 )
 ```
 
-#### 9.5 开发安装
+#### 9.4 开发安装
 
 使用 `-e` 参数进行可编辑安装，这样代码修改后立即生效：
 
@@ -923,7 +860,7 @@ pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 - 方便调试和测试
 - 支持版本控制（git）
 
-#### 9.6 编写设备驱动
+#### 9.5 编写设备驱动
 
 创建设备驱动文件：
 
@@ -1064,7 +1001,7 @@ class MyPump:
 - **返回 Dict**：所有动作方法返回字典类型
 - **文档字符串**：详细说明参数和功能
 
-#### 9.7 测试设备驱动
+#### 9.6 测试设备驱动
 
 创建简单的测试脚本：
 

docs/user_guide/installation.md

@@ -13,26 +13,15 @@
   - 开发者需要 Git 和基本的 Python 开发知识
   - 自定义 msgs 需要 GitHub 账号
 
-## 安装包选择
-
-Uni-Lab-OS 提供三个安装包版本，根据您的需求选择：
-
-| 安装包 | 适用场景 | 包含组件 | 磁盘占用 |
-|--------|----------|----------|----------|
-| **unilabos** | **推荐大多数用户**，生产部署 | 完整安装包，开箱即用 | ~2-3 GB |
-| **unilabos-env** | 开发者环境（可编辑安装） | 仅环境依赖，通过 pip 安装 unilabos | ~2 GB |
-| **unilabos-full** | 仿真可视化、完整功能体验 | unilabos + 完整 ROS2 桌面版 + Gazebo + MoveIt | ~8-10 GB |
-
 ## 安装方式选择
 
 根据您的使用场景，选择合适的安装方式：
 
-| 安装方式               | 适用人群             | 推荐安装包        | 特点                           | 安装时间                     |
-| ---------------------- | -------------------- | ----------------- | ------------------------------ | ---------------------------- |
-| **方式一：一键安装**   | 快速体验、演示       | 预打包环境        | 离线可用，无需配置             | 5-10 分钟 (网络良好的情况下) |
-| **方式二：手动安装**   | **大多数用户**       | `unilabos`        | 完整功能，开箱即用             | 10-20 分钟                   |
-| **方式三：开发者安装** | 开发者、需要修改源码 | `unilabos-env`    | 可编辑模式，支持自定义开发     | 20-30 分钟                   |
-| **仿真/可视化**        | 仿真测试、可视化调试 | `unilabos-full`   | 含 Gazebo、rviz2、MoveIt       | 30-60 分钟                   |
+| 安装方式               | 适用人群             | 特点                           | 安装时间                     |
+| ---------------------- | -------------------- | ------------------------------ | ---------------------------- |
+| **方式一：一键安装**   | 实验室用户、快速体验 | 预打包环境，离线可用，无需配置 | 5-10 分钟 (网络良好的情况下) |
+| **方式二：手动安装**   | 标准用户、生产环境   | 灵活配置，版本可控             | 10-20 分钟                   |
+| **方式三：开发者安装** | 开发者、需要修改源码 | 可编辑模式，支持自定义 msgs    | 20-30 分钟                   |
 
 ---
 
@@ -155,38 +144,17 @@ bash Miniforge3-$(uname)-$(uname -m).sh
 使用以下命令创建 Uni-Lab 专用环境：
 
 ```bash
-mamba create -n unilab python=3.11.14  # 目前ros2组件依赖版本大多为3.11.14
+mamba create -n unilab python=3.11.11  # 目前ros2组件依赖版本大多为3.11.11
 mamba activate unilab
-
-# 选择安装包（三选一）：
-
-# 方案 A：标准安装（推荐大多数用户）
-mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-
-# 方案 B：开发者环境（可编辑模式开发）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-# 然后安装 unilabos 和 pip 依赖：
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git && cd Uni-Lab-OS
-pip install -e .
-uv pip install -r unilabos/utils/requirements.txt
-
-# 方案 C：完整版（含仿真和可视化工具）
-mamba install uni-lab::unilabos-full -c robostack-staging -c conda-forge
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
 **参数说明**:
 
 - `-n unilab`: 创建名为 "unilab" 的环境
-- `uni-lab::unilabos`: 安装 unilabos 完整包，开箱即用（推荐）
-- `uni-lab::unilabos-env`: 仅安装环境依赖，适合开发者使用 `pip install -e .`
-- `uni-lab::unilabos-full`: 安装完整包（含 ROS2 Desktop、Gazebo、MoveIt 等）
+- `uni-lab::unilabos`: 从 uni-lab channel 安装 unilabos 包
 - `-c robostack-staging -c conda-forge`: 添加额外的软件源
 
-**包选择建议**：
-- **日常使用/生产部署**：安装 `unilabos`（推荐，完整功能，开箱即用）
-- **开发者**：安装 `unilabos-env`，然后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖，再 `pip install -e .` 进行可编辑安装
-- **仿真/可视化**：安装 `unilabos-full`（Gazebo、rviz2、MoveIt）
-
 **如果遇到网络问题**，可以使用清华镜像源加速下载：
 
 ```bash
@@ -195,14 +163,8 @@ mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/m
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
 mamba config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
 
-# 然后重新执行安装命令（推荐标准安装）
+# 然后重新执行安装命令
 mamba create -n unilab uni-lab::unilabos -c robostack-staging
-
-# 或完整版（仿真/可视化）
-mamba create -n unilab uni-lab::unilabos-full -c robostack-staging
-
-# pip 安装时使用清华镜像（开发者安装时使用）
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```
 
 ### 第三步：激活环境
@@ -241,87 +203,58 @@ cd Uni-Lab-OS
    cd Uni-Lab-OS
    ```
 
-### 第二步：安装开发环境（unilabos-env）
+### 第二步：安装基础环境
 
-**重要**：开发者请使用 `unilabos-env` 包，它专为开发者设计：
-- 包含 ROS2 核心组件和消息包（ros-humble-ros-core、std-msgs、geometry-msgs 等）
-- 包含 transforms3d、cv-bridge、tf2 等 conda 依赖
-- 包含 `uv` 工具，用于快速安装 pip 依赖
-- **不包含** pip 依赖和 unilabos 包（由 `pip install -e .` 和 `uv pip install` 安装）
+**推荐方式**：先通过**方式一（一键安装）**或**方式二（手动安装）**完成基础环境的安装，这将包含所有必需的依赖项（ROS2、msgs 等）。
+
+#### 选项 A：通过一键安装（推荐）
+
+参考上文"方式一：一键安装"，完成基础环境的安装后，激活环境：
 
 ```bash
-# 创建并激活环境
-mamba create -n unilab python=3.11.14
 conda activate unilab
-
-# 安装开发者环境包（ROS2 + conda 依赖 + uv）
-mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
 ```
 
-### 第三步：安装 pip 依赖和可编辑模式安装
+#### 选项 B：通过手动安装
 
-克隆代码并安装依赖：
+参考上文"方式二：手动安装"，创建并安装环境：
+
+```bash
+mamba create -n unilab python=3.11.11
+conda activate unilab
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
+```
+
+**说明**：这会安装包括 Python 3.11.11、ROS2 Humble、ros-humble-unilabos-msgs 和所有必需依赖
+
+### 第三步：切换到开发版本
+
+现在你已经有了一个完整可用的 Uni-Lab 环境，接下来将 unilabos 包切换为开发版本：
 
 ```bash
 # 确保环境已激活
 conda activate unilab
 
-# 克隆仓库（如果还未克隆）
-git clone https://github.com/deepmodeling/Uni-Lab-OS.git
-cd Uni-Lab-OS
+# 卸载 pip 安装的 unilabos（保留所有 conda 依赖）
+pip uninstall unilabos -y
 
-# 切换到 dev 分支（可选）
+# 克隆 dev 分支（如果还未克隆）
+cd /path/to/your/workspace
+git clone -b dev https://github.com/deepmodeling/Uni-Lab-OS.git
+# 或者如果已经克隆，切换到 dev 分支
+cd Uni-Lab-OS
 git checkout dev
 git pull
-```
 
-**推荐：使用安装脚本**（自动检测中文环境，使用 uv 加速）：
-
-```bash
-# 自动检测中文环境，如果是中文系统则使用清华镜像
-python scripts/dev_install.py
-
-# 或者手动指定：
-python scripts/dev_install.py --china     # 强制使用清华镜像
-python scripts/dev_install.py --no-mirror # 强制使用 PyPI
-python scripts/dev_install.py --skip-deps # 跳过 pip 依赖安装
-python scripts/dev_install.py --use-pip   # 使用 pip 而非 uv
-```
-
-**手动安装**（如果脚本安装失败或速度太慢）：
-
-```bash
-# 1. 安装 unilabos（可编辑模式）
-pip install -e .
-
-# 2. 使用 uv 安装 pip 依赖（推荐，速度更快）
-uv pip install -r unilabos/utils/requirements.txt
-
-# 国内用户使用清华镜像：
+# 以可编辑模式安装开发版 unilabos
 pip install -e . -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-uv pip install -r unilabos/utils/requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
 ```
 
-**注意**：
-- `uv` 已包含在 `unilabos-env` 中，无需单独安装
-- `unilabos/utils/requirements.txt` 包含运行 unilabos 所需的所有 pip 依赖
-- 部分特殊包（如 pylabrobot）会在运行时由 unilabos 自动检测并安装
+**参数说明**：
 
-**为什么使用可编辑模式？**
-
-- `-e` (editable mode)：代码修改**立即生效**，无需重新安装
-- 适合开发调试：修改代码后直接运行测试
-- 与 `unilabos-env` 配合：环境依赖由 conda 管理，unilabos 代码由 pip 管理
-
-**验证安装**：
-
-```bash
-# 检查 unilabos 版本
-python -c "import unilabos; print(unilabos.__version__)"
-
-# 检查安装位置（应该指向你的代码目录）
-pip show unilabos | grep Location
-```
+- `-e`: editable mode（可编辑模式），代码修改立即生效，无需重新安装
+- `-i`: 使用清华镜像源加速下载
+- `pip uninstall unilabos`: 只卸载 pip 安装的 unilabos 包，不影响 conda 安装的其他依赖（如 ROS2、msgs 等）
 
 ### 第四步：安装或自定义 ros-humble-unilabos-msgs（可选）
 
@@ -531,45 +464,7 @@ cd $CONDA_PREFIX/envs/unilab
 
 ### 问题 8: 环境很大，有办法减小吗？
 
-**解决方案**: 
-
-1. **使用 `unilabos` 标准版**（推荐大多数用户）：
-   ```bash
-   mamba install uni-lab::unilabos -c robostack-staging -c conda-forge
-   ```
-   标准版包含完整功能，环境大小约 2-3GB（相比完整版的 8-10GB）。
-
-2. **使用 `unilabos-env` 开发者版**（最小化）：
-   ```bash
-   mamba install uni-lab::unilabos-env -c robostack-staging -c conda-forge
-   # 然后手动安装依赖
-   pip install -e .
-   uv pip install -r unilabos/utils/requirements.txt
-   ```
-   开发者版只包含环境依赖，体积最小约 2GB。
-
-3. **按需安装额外组件**：
-   如果后续需要特定功能，可以单独安装：
-   ```bash
-   # 需要 Jupyter
-   mamba install jupyter jupyros
-   
-   # 需要可视化
-   mamba install matplotlib opencv
-   
-   # 需要仿真（注意：这会安装大量依赖）
-   mamba install ros-humble-gazebo-ros
-   ```
-
-4. **预打包环境问题**：
-   预打包环境（方式一）包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。
-
-**包选择建议**：
-| 需求 | 推荐包 | 预估大小 |
-|------|--------|----------|
-| 日常使用/生产部署 | `unilabos` | ~2-3 GB |
-| 开发调试（可编辑模式） | `unilabos-env` | ~2 GB |
-| 仿真/可视化 | `unilabos-full` | ~8-10 GB |
+**解决方案**: 预打包的环境包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。如果空间有限，考虑使用方式二手动安装，只安装需要的组件。
 
 ### 问题 9: 如何更新到最新版本？
 
@@ -616,7 +511,6 @@ mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-f
 
 **提示**:
 
-- **大多数用户**推荐使用方式二（手动安装）的 `unilabos` 标准版
-- **开发者**推荐使用方式三（开发者安装），安装 `unilabos-env` 后使用 `uv pip install -r unilabos/utils/requirements.txt` 安装依赖
-- **仿真/可视化**推荐安装 `unilabos-full` 完整版
-- **快速体验和演示**推荐使用方式一（一键安装）
+- 生产环境推荐使用方式二（手动安装）的稳定版本
+- 开发和测试推荐使用方式三（开发者安装）
+- 快速体验和演示推荐使用方式一（一键安装）

recipes/msgs/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.10.18
+  version: 0.10.15
 source:
   path: ../../unilabos_msgs
   target_directory: src
@@ -25,7 +25,7 @@ requirements:
   build:
   - ${{ compiler('cxx') }}
   - ${{ compiler('c') }}
-  - python ==3.11.14
+  - python ==3.11.11
   - numpy
   - if: build_platform != target_platform
     then:
@@ -63,14 +63,14 @@ requirements:
   - robostack-staging::ros-humble-rosidl-default-generators
   - robostack-staging::ros-humble-std-msgs
   - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
   run:
   - robostack-staging::ros-humble-action-msgs
   - robostack-staging::ros-humble-ros-workspace
   - robostack-staging::ros-humble-rosidl-default-runtime
   - robostack-staging::ros-humble-std-msgs
   - robostack-staging::ros-humble-geometry-msgs
-  - robostack-staging::ros2-distro-mutex=0.7
+  - robostack-staging::ros2-distro-mutex=0.6
   - if: osx and x86_64
     then:
     - __osx >=${{ MACOSX_DEPLOYMENT_TARGET|default('10.14') }}

recipes/unilabos/recipe.yaml

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

scripts/create_readme.py

@@ -85,7 +85,7 @@ Verification:
 -------------
 
 The verify_installation.py script will check:
-  - Python version (3.11.14)
+  - Python version (3.11.11)
   - ROS2 rclpy installation
   - UniLabOS installation and dependencies
 
@@ -104,7 +104,7 @@ Build Information:
 
   Branch:   {branch}
   Platform: {platform}
-  Python:   3.11.14
+  Python:   3.11.11
   Date:     {build_date}
 
 Troubleshooting:

scripts/dev_install.py

@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""
-Development installation script for UniLabOS.
-Auto-detects Chinese locale and uses appropriate mirror.
-
-Usage:
-    python scripts/dev_install.py
-    python scripts/dev_install.py --no-mirror  # Force no mirror
-    python scripts/dev_install.py --china      # Force China mirror
-    python scripts/dev_install.py --skip-deps  # Skip pip dependencies installation
-
-Flow:
-    1. pip install -e . (install unilabos in editable mode)
-    2. Detect Chinese locale
-    3. Use uv to install pip dependencies from requirements.txt
-    4. Special packages (like pylabrobot) are handled by environment_check.py at runtime
-"""
-
-import locale
-import subprocess
-import sys
-import argparse
-from pathlib import Path
-
-# Tsinghua mirror URL
-TSINGHUA_MIRROR = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
-
-
-def is_chinese_locale() -> bool:
-    """
-    Detect if system is in Chinese locale.
-    Same logic as EnvironmentChecker._is_chinese_locale()
-    """
-    try:
-        lang = locale.getdefaultlocale()[0]
-        if lang and ("zh" in lang.lower() or "chinese" in lang.lower()):
-            return True
-    except Exception:
-        pass
-    return False
-
-
-def run_command(cmd: list, description: str, retry: int = 2) -> bool:
-    """Run command with retry support."""
-    print(f"[INFO] {description}")
-    print(f"[CMD] {' '.join(cmd)}")
-
-    for attempt in range(retry + 1):
-        try:
-            result = subprocess.run(cmd, check=True, timeout=600)
-            print(f"[OK] {description}")
-            return True
-        except subprocess.CalledProcessError as e:
-            if attempt < retry:
-                print(f"[WARN] Attempt {attempt + 1} failed, retrying...")
-            else:
-                print(f"[ERROR] {description} failed: {e}")
-                return False
-        except subprocess.TimeoutExpired:
-            print(f"[ERROR] {description} timed out")
-            return False
-    return False
-
-
-def install_editable(project_root: Path, use_mirror: bool) -> bool:
-    """Install unilabos in editable mode using pip."""
-    cmd = [sys.executable, "-m", "pip", "install", "-e", str(project_root)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing unilabos in editable mode")
-
-
-def install_requirements_uv(requirements_file: Path, use_mirror: bool) -> bool:
-    """Install pip dependencies using uv (installed via conda-forge::uv)."""
-    cmd = ["uv", "pip", "install", "-r", str(requirements_file)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing pip dependencies with uv", retry=2)
-
-
-def install_requirements_pip(requirements_file: Path, use_mirror: bool) -> bool:
-    """Fallback: Install pip dependencies using pip."""
-    cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
-    if use_mirror:
-        cmd.extend(["-i", TSINGHUA_MIRROR])
-
-    return run_command(cmd, "Installing pip dependencies with pip", retry=2)
-
-
-def check_uv_available() -> bool:
-    """Check if uv is available (installed via conda-forge::uv)."""
-    try:
-        subprocess.run(["uv", "--version"], capture_output=True, check=True)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Development installation script for UniLabOS")
-    parser.add_argument("--china", action="store_true", help="Force use China mirror (Tsinghua)")
-    parser.add_argument("--no-mirror", action="store_true", help="Force use default PyPI (no mirror)")
-    parser.add_argument(
-        "--skip-deps", action="store_true", help="Skip pip dependencies installation (only install unilabos)"
-    )
-    parser.add_argument("--use-pip", action="store_true", help="Use pip instead of uv for dependencies")
-    args = parser.parse_args()
-
-    # Determine project root
-    script_dir = Path(__file__).parent
-    project_root = script_dir.parent
-    requirements_file = project_root / "unilabos" / "utils" / "requirements.txt"
-
-    if not (project_root / "setup.py").exists():
-        print(f"[ERROR] setup.py not found in {project_root}")
-        sys.exit(1)
-
-    print("=" * 60)
-    print("UniLabOS Development Installation")
-    print("=" * 60)
-    print(f"Project root: {project_root}")
-    print()
-
-    # Determine mirror usage based on locale
-    if args.no_mirror:
-        use_mirror = False
-        print("[INFO] Mirror disabled by --no-mirror flag")
-    elif args.china:
-        use_mirror = True
-        print("[INFO] China mirror enabled by --china flag")
-    else:
-        use_mirror = is_chinese_locale()
-        if use_mirror:
-            print("[INFO] Chinese locale detected, using Tsinghua mirror")
-        else:
-            print("[INFO] Non-Chinese locale detected, using default PyPI")
-
-    print()
-
-    # Step 1: Install unilabos in editable mode
-    print("[STEP 1] Installing unilabos in editable mode...")
-    if not install_editable(project_root, use_mirror):
-        print("[ERROR] Failed to install unilabos")
-        print()
-        print("Manual fallback:")
-        if use_mirror:
-            print(f"  pip install -e {project_root} -i {TSINGHUA_MIRROR}")
-        else:
-            print(f"  pip install -e {project_root}")
-        sys.exit(1)
-
-    print()
-
-    # Step 2: Install pip dependencies
-    if args.skip_deps:
-        print("[INFO] Skipping pip dependencies installation (--skip-deps)")
-    else:
-        print("[STEP 2] Installing pip dependencies...")
-
-        if not requirements_file.exists():
-            print(f"[WARN] Requirements file not found: {requirements_file}")
-            print("[INFO] Skipping dependencies installation")
-        else:
-            # Try uv first (faster), fallback to pip
-            if args.use_pip:
-                print("[INFO] Using pip (--use-pip flag)")
-                success = install_requirements_pip(requirements_file, use_mirror)
-            elif check_uv_available():
-                print("[INFO] Using uv (installed via conda-forge::uv)")
-                success = install_requirements_uv(requirements_file, use_mirror)
-                if not success:
-                    print("[WARN] uv failed, falling back to pip...")
-                    success = install_requirements_pip(requirements_file, use_mirror)
-            else:
-                print("[WARN] uv not available (should be installed via: mamba install conda-forge::uv)")
-                print("[INFO] Falling back to pip...")
-                success = install_requirements_pip(requirements_file, use_mirror)
-
-            if not success:
-                print()
-                print("[WARN] Failed to install some dependencies automatically.")
-                print("You can manually install them:")
-                if use_mirror:
-                    print(f"  uv pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
-                    print("  or:")
-                    print(f"  pip install -r {requirements_file} -i {TSINGHUA_MIRROR}")
-                else:
-                    print(f"  uv pip install -r {requirements_file}")
-                    print("  or:")
-                    print(f"  pip install -r {requirements_file}")
-
-    print()
-    print("=" * 60)
-    print("Installation complete!")
-    print("=" * 60)
-    print()
-    print("Note: Some special packages (like pylabrobot) are installed")
-    print("automatically at runtime by unilabos if needed.")
-    print()
-    print("Verify installation:")
-    print('  python -c "import unilabos; print(unilabos.__version__)"')
-    print()
-    print("If you encounter issues, you can manually install dependencies:")
-    if use_mirror:
-        print(f"  uv pip install -r unilabos/utils/requirements.txt -i {TSINGHUA_MIRROR}")
-    else:
-        print("  uv pip install -r unilabos/utils/requirements.txt")
-    print()
-
-
-if __name__ == "__main__":
-    main()

setup.py

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

tests/devices/liquid_handling/README.md

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

tests/devices/liquid_handling/unit_test.py

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

tests/workflow/test.json

@@ -1,213 +0,0 @@
-{
-  "workflow": [
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_1",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines",
-        "targets": "Liquid_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_4",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_5",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_2",
-        "targets": "Liquid_6",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_2",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    },
-    {
-      "action": "transfer_liquid",
-      "action_args": {
-        "sources": "cell_lines_3",
-        "targets": "dest_set_3",
-        "asp_vol": 100.0,
-        "dis_vol": 74.75,
-        "asp_flow_rate": 94.0,
-        "dis_flow_rate": 95.5
-      }
-    }
-  ],
-  "reagent": {
-    "Liquid_1": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_4": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "dest_set": {
-      "slot": 1,
-      "well": [
-        "A4",
-        "A7",
-        "A10"
-      ],
-      "labware": "rep 1"
-    },
-    "Liquid_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_5": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "dest_set_2": {
-      "slot": 2,
-      "well": [
-        "A3",
-        "A5",
-        "A8"
-      ],
-      "labware": "rep 2"
-    },
-    "Liquid_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "Liquid_6": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "dest_set_3": {
-      "slot": 3,
-      "well": [
-        "A4",
-        "A6",
-        "A10"
-      ],
-      "labware": "rep 3"
-    },
-    "cell_lines": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_2": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    },
-    "cell_lines_3": {
-      "slot": 4,
-      "well": [
-        "A1",
-        "A3",
-        "A5"
-      ],
-      "labware": "DRUG + YOYO-MEDIA"
-    }
-  }
-}

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.18"
+__version__ = "0.10.15"

unilabos/__main__.py

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

unilabos/app/main.py

@@ -1,13 +1,13 @@
 import argparse
 import asyncio
 import os
-import platform
 import shutil
 import signal
 import sys
 import threading
 import time
 from typing import Dict, Any, List
+
 import networkx as nx
 import yaml
 
@@ -17,9 +17,9 @@ unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
     sys.path.append(unilabos_dir)
 
-from unilabos.app.utils import cleanup_for_restart
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
+from unilabos.app.utils import cleanup_for_restart
 
 # Global restart flags (used by ws_client and web/server)
 _restart_requested: bool = False
@@ -161,23 +161,11 @@ def parse_args():
         default=False,
         help="Complete registry information",
     )
-    parser.add_argument(
-        "--check_mode",
-        action="store_true",
-        default=False,
-        help="Run in check mode for CI: validates registry imports and ensures no file changes",
-    )
     parser.add_argument(
         "--no_update_feedback",
         action="store_true",
         help="Disable sending update feedback to server",
     )
-    parser.add_argument(
-        "--test_mode",
-        action="store_true",
-        default=False,
-        help="Test mode: all actions simulate execution and return mock results without running real hardware",
-    )
     # workflow upload subcommand
     workflow_parser = subparsers.add_parser(
         "workflow_upload",
@@ -211,12 +199,6 @@ def parse_args():
         default=False,
         help="Whether to publish the workflow (default: False)",
     )
-    workflow_parser.add_argument(
-        "--description",
-        type=str,
-        default="",
-        help="Workflow description, used when publishing the workflow",
-    )
     return parser
 
 
@@ -229,10 +211,7 @@ def main():
     args_dict = vars(args)
 
     # 环境检查 - 检查并自动安装必需的包 (可选)
-    skip_env_check = args_dict.get("skip_env_check", False)
-    check_mode = args_dict.get("check_mode", False)
-
-    if not skip_env_check:
+    if not args_dict.get("skip_env_check", False):
         from unilabos.utils.environment_check import check_environment
 
         if not check_environment(auto_install=True):
@@ -243,75 +222,49 @@ def main():
 
     # 加载配置文件，优先加载config，然后从env读取
     config_path = args_dict.get("config")
-
-    # === 解析 working_dir ===
-    # 规则1: working_dir 传入 → 检测 unilabos_data 子目录，已是则不修改
-    # 规则2: 仅 config_path 传入 → 用其父目录作为 working_dir
-    # 规则4: 两者都传入 → 各用各的，但 working_dir 仍做 unilabos_data 子目录检测
-    raw_working_dir = args_dict.get("working_dir")
-    if raw_working_dir:
-        working_dir = os.path.abspath(raw_working_dir)
-    elif config_path and os.path.exists(config_path):
-        working_dir = os.path.dirname(os.path.abspath(config_path))
-    else:
+    if os.getcwd().endswith("unilabos_data"):
         working_dir = os.path.abspath(os.getcwd())
+    else:
+        working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))
 
-    # unilabos_data 子目录自动检测
-    if os.path.basename(working_dir) != "unilabos_data":
-        unilabos_data_sub = os.path.join(working_dir, "unilabos_data")
-        if os.path.isdir(unilabos_data_sub):
-            working_dir = unilabos_data_sub
-        elif not raw_working_dir and not (config_path and os.path.exists(config_path)):
-            # 未显式指定路径，默认使用 cwd/unilabos_data
-            working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))
-
-    # === 解析 config_path ===
-    if config_path and not os.path.exists(config_path):
-        # config_path 传入但不存在，尝试在 working_dir 中查找
-        candidate = os.path.join(working_dir, "local_config.py")
-        if os.path.exists(candidate):
-            config_path = candidate
-            print_status(f"在工作目录中发现配置文件: {config_path}", "info")
-        else:
-            print_status(
-                f"配置文件 {config_path} 不存在，工作目录 {working_dir} 中也未找到 local_config.py，"
-                f"请通过 --config 传入 local_config.py 文件路径",
-                "error",
-            )
-            os._exit(1)
-    elif not config_path:
-        # 规则3: 未传入 config_path，尝试 working_dir/local_config.py
-        candidate = os.path.join(working_dir, "local_config.py")
-        if os.path.exists(candidate):
-            config_path = candidate
-            print_status(f"发现本地配置文件: {config_path}", "info")
-        else:
-            print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
-            print_status(f"您是否为第一次使用？并将当前路径 {working_dir} 作为工作目录？ (Y/n)", "info")
-            if check_mode or input() != "n":
-                os.makedirs(working_dir, exist_ok=True)
-                config_path = os.path.join(working_dir, "local_config.py")
-                shutil.copy(
-                    os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"),
-                    config_path,
+    if args_dict.get("working_dir"):
+        working_dir = args_dict.get("working_dir", "")
+        if config_path and not os.path.exists(config_path):
+            config_path = os.path.join(working_dir, "local_config.py")
+            if not os.path.exists(config_path):
+                print_status(
+                    f"当前工作目录 {working_dir} 未找到local_config.py，请通过 --config 传入 local_config.py 文件路径",
+                    "error",
                 )
-                print_status(f"已创建 local_config.py 路径： {config_path}", "info")
-            else:
                 os._exit(1)
-
-    # 加载配置文件 (check_mode 跳过)
+    elif config_path and os.path.exists(config_path):
+        working_dir = os.path.dirname(config_path)
+    elif os.path.exists(working_dir) and os.path.exists(os.path.join(working_dir, "local_config.py")):
+        config_path = os.path.join(working_dir, "local_config.py")
+    elif not config_path and (
+        not os.path.exists(working_dir) or not os.path.exists(os.path.join(working_dir, "local_config.py"))
+    ):
+        print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
+        print_status(f"您是否为第一次使用？并将当前路径 {working_dir} 作为工作目录？ (Y/n)", "info")
+        if input() != "n":
+            os.makedirs(working_dir, exist_ok=True)
+            config_path = os.path.join(working_dir, "local_config.py")
+            shutil.copy(
+                os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"), config_path
+            )
+            print_status(f"已创建 local_config.py 路径： {config_path}", "info")
+        else:
+            os._exit(1)
+    # 加载配置文件
     print_status(f"当前工作目录为 {working_dir}", "info")
-    if not check_mode:
-        load_config_from_file(config_path)
+    load_config_from_file(config_path)
 
     # 根据配置重新设置日志级别
     from unilabos.utils.log import configure_logger, logger
 
     if hasattr(BasicConfig, "log_level"):
         logger.info(f"Log level set to '{BasicConfig.log_level}' from config file.")
-    file_path = configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
-    if file_path is not None:
-        logger.info(f"[LOG_FILE] {file_path}")
+    configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
 
     if args.addr != parser.get_default("addr"):
         if args.addr == "test":
@@ -355,15 +308,11 @@ def main():
     BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
     BasicConfig.upload_registry = args_dict.get("upload_registry", False)
     BasicConfig.no_update_feedback = args_dict.get("no_update_feedback", False)
-    BasicConfig.test_mode = args_dict.get("test_mode", False)
-    if BasicConfig.test_mode:
-        print_status("启用测试模式：所有动作将模拟执行，不调用真实硬件", "warning")
     BasicConfig.communication_protocol = "websocket"
-    machine_name = platform.node()
+    machine_name = os.popen("hostname").read().strip()
     machine_name = "".join([c if c.isalnum() or c == "_" else "_" for c in machine_name])
     BasicConfig.machine_name = machine_name
     BasicConfig.vis_2d_enable = args_dict["2d_vis"]
-    BasicConfig.check_mode = check_mode
 
     from unilabos.resources.graphio import (
         read_node_link_json,
@@ -382,14 +331,10 @@ def main():
     # 显示启动横幅
     print_unilab_banner(args_dict)
 
-    # 注册表 - check_mode 时强制启用 complete_registry
-    complete_registry = args_dict.get("complete_registry", False) or check_mode
-    lab_registry = build_registry(args_dict["registry_path"], complete_registry, BasicConfig.upload_registry)
-
-    # Check mode: complete_registry 完成后直接退出，git diff 检测由 CI workflow 执行
-    if check_mode:
-        print_status("Check mode: complete_registry 完成，退出", "info")
-        os._exit(0)
+    # 注册表
+    lab_registry = build_registry(
+        args_dict["registry_path"], args_dict.get("complete_registry", False), BasicConfig.upload_registry
+    )
 
     if BasicConfig.upload_registry:
         # 设备注册到服务端 - 需要 ak 和 sk

unilabos/app/model.py

@@ -54,7 +54,6 @@ class JobAddReq(BaseModel):
     action_type: str = Field(
         examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action type", default=""
     )
-    sample_material: dict = Field(examples=[{"string": "string"}], description="sample uuid to material uuid")
     action_args: dict = Field(examples=[{"string": "string"}], description="action arguments", default_factory=dict)
     task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
     job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")

unilabos/app/register.py

@@ -38,9 +38,9 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
             response = http_client.resource_registry({"resources": list(devices_to_register.values())})
             cost_time = time.time() - start_time
             if response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}s")
+                logger.info(f"[UniLab Register] 成功注册 {len(devices_to_register)} 个设备 {cost_time}ms")
             else:
-                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}s")
+                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}ms")
         except Exception as e:
             logger.error(f"[UniLab Register] 设备注册异常: {e}")
 
@@ -51,9 +51,9 @@ def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[
             response = http_client.resource_registry({"resources": list(resources_to_register.values())})
             cost_time = time.time() - start_time
             if response.status_code in [200, 201]:
-                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}s")
+                logger.info(f"[UniLab Register] 成功注册 {len(resources_to_register)} 个资源 {cost_time}ms")
             else:
-                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}s")
+                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}ms")
         except Exception as e:
             logger.error(f"[UniLab Register] 资源注册异常: {e}")
 

unilabos/app/utils.py

@@ -4,40 +4,8 @@ UniLabOS 应用工具函数
 提供清理、重启等工具函数
 """
 
-import glob
-import os
-import shutil
-import sys
-
-
-def patch_rclpy_dll_windows():
-    """在 Windows + conda 环境下为 rclpy 打 DLL 加载补丁"""
-    if sys.platform != "win32" or not os.environ.get("CONDA_PREFIX"):
-        return
-    try:
-        import rclpy
-
-        return
-    except ImportError as e:
-        if not str(e).startswith("DLL load failed"):
-            return
-    cp = os.environ["CONDA_PREFIX"]
-    impl = os.path.join(cp, "Lib", "site-packages", "rclpy", "impl", "implementation_singleton.py")
-    pyd = glob.glob(os.path.join(cp, "Lib", "site-packages", "rclpy", "_rclpy_pybind11*.pyd"))
-    if not os.path.exists(impl) or not pyd:
-        return
-    with open(impl, "r", encoding="utf-8") as f:
-        content = f.read()
-    lib_bin = os.path.join(cp, "Library", "bin").replace("\\", "/")
-    patch = f'# UniLabOS DLL Patch\nimport os,ctypes\nos.add_dll_directory("{lib_bin}") if hasattr(os,"add_dll_directory") else None\ntry: ctypes.CDLL("{pyd[0].replace(chr(92),"/")}")\nexcept: pass\n# End Patch\n'
-    shutil.copy2(impl, impl + ".bak")
-    with open(impl, "w", encoding="utf-8") as f:
-        f.write(patch + content)
-
-
-patch_rclpy_dll_windows()
-
 import gc
+import os
 import threading
 import time
 

unilabos/app/web/client.py

@@ -3,7 +3,7 @@ HTTP客户端模块
 
 提供与远程服务器通信的客户端功能，只有host需要用
 """
-import gzip
+
 import json
 import os
 from typing import List, Dict, Any, Optional
@@ -290,17 +290,10 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        compressed_body = gzip.compress(
-            json.dumps(registry_data, ensure_ascii=False, default=str).encode("utf-8")
-        )
         response = requests.post(
             f"{self.remote_addr}/lab/resource",
-            data=compressed_body,
-            headers={
-                "Authorization": f"Lab {self.auth}",
-                "Content-Type": "application/json",
-                "Content-Encoding": "gzip",
-            },
+            json=registry_data,
+            headers={"Authorization": f"Lab {self.auth}"},
             timeout=30,
         )
         if response.status_code not in [200, 201]:
@@ -350,10 +343,9 @@ class HTTPClient:
         edges: List[Dict[str, Any]],
         tags: Optional[List[str]] = None,
         published: bool = False,
-        description: str = "",
     ) -> Dict[str, Any]:
         """
-        导入工作流到服务器，如果 published 为 True，则额外发起发布请求
+        导入工作流到服务器
 
         Args:
             name: 工作流名称（顶层）
@@ -363,12 +355,13 @@ class HTTPClient:
             edges: 工作流边列表
             tags: 工作流标签列表，默认为空列表
             published: 是否发布工作流，默认为False
-            description: 工作流描述，发布时使用
 
         Returns:
             Dict: API响应数据，包含 code 和 data (uuid, name)
         """
+        # target_lab_uuid 暂时使用默认值，后续由后端根据 ak/sk 获取
         payload = {
+            "target_lab_uuid": "28c38bb0-63f6-4352-b0d8-b5b8eb1766d5",
             "name": name,
             "data": {
                 "workflow_uuid": workflow_uuid,
@@ -376,6 +369,7 @@ class HTTPClient:
                 "nodes": nodes,
                 "edges": edges,
                 "tags": tags if tags is not None else [],
+                "published": published,
             },
         }
         # 保存请求到文件
@@ -396,51 +390,11 @@ class HTTPClient:
             res = response.json()
             if "code" in res and res["code"] != 0:
                 logger.error(f"导入工作流失败: {response.text}")
-                return res
-            # 导入成功后，如果需要发布则额外发起发布请求
-            if published:
-                imported_uuid = res.get("data", {}).get("uuid", workflow_uuid)
-                publish_res = self.workflow_publish(imported_uuid, description)
-                res["publish_result"] = publish_res
             return res
         else:
             logger.error(f"导入工作流失败: {response.status_code}, {response.text}")
             return {"code": response.status_code, "message": response.text}
 
-    def workflow_publish(self, workflow_uuid: str, description: str = "") -> Dict[str, Any]:
-        """
-        发布工作流
-
-        Args:
-            workflow_uuid: 工作流UUID
-            description: 工作流描述
-
-        Returns:
-            Dict: API响应数据
-        """
-        payload = {
-            "uuid": workflow_uuid,
-            "description": description,
-            "published": True,
-        }
-        logger.info(f"正在发布工作流: {workflow_uuid}")
-        response = requests.patch(
-            f"{self.remote_addr}/lab/workflow/owner",
-            json=payload,
-            headers={"Authorization": f"Lab {self.auth}"},
-            timeout=60,
-        )
-        if response.status_code == 200:
-            res = response.json()
-            if "code" in res and res["code"] != 0:
-                logger.error(f"发布工作流失败: {response.text}")
-            else:
-                logger.info(f"工作流发布成功: {workflow_uuid}")
-            return res
-        else:
-            logger.error(f"发布工作流失败: {response.status_code}, {response.text}")
-            return {"code": response.status_code, "message": response.text}
-
 
 # 创建默认客户端实例
 http_client = HTTPClient()

unilabos/app/web/controller.py

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

unilabos/app/ws_client.py

@@ -23,7 +23,7 @@ from typing import Optional, Dict, Any, List
 from urllib.parse import urlparse
 from enum import Enum
 
-from typing_extensions import TypedDict
+from jedi.inference.gradual.typing import TypedDict
 
 from unilabos.app.model import JobAddReq
 from unilabos.ros.nodes.presets.host_node import HostNode
@@ -76,7 +76,6 @@ class JobInfo:
     start_time: float
     last_update_time: float = field(default_factory=time.time)
     ready_timeout: Optional[float] = None  # READY状态的超时时间
-    always_free: bool = False  # 是否为永久闲置动作(不受排队限制)
 
     def update_timestamp(self):
         """更新最后更新时间"""
@@ -128,15 +127,6 @@ class DeviceActionManager:
             # 总是将job添加到all_jobs中
             self.all_jobs[job_info.job_id] = job_info
 
-            # always_free的动作不受排队限制，直接设为READY
-            if job_info.always_free:
-                job_info.status = JobStatus.READY
-                job_info.update_timestamp()
-                job_info.set_ready_timeout(10)
-                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Job {job_log} always_free, start immediately")
-                return True
-
             # 检查是否有正在执行或准备执行的任务
             if device_key in self.active_jobs:
                 # 有正在执行或准备执行的任务，加入队列
@@ -164,7 +154,7 @@ class DeviceActionManager:
             job_info.set_ready_timeout(10)  # 设置10秒超时
             self.active_jobs[device_key] = job_info
             job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-            logger.trace(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
+            logger.info(f"[DeviceActionManager] Job {job_log} can start immediately for {device_key}")
             return True
 
     def start_job(self, job_id: str) -> bool:
@@ -186,15 +176,11 @@ class DeviceActionManager:
                 logger.error(f"[DeviceActionManager] Job {job_log} is not in READY status, current: {job_info.status}")
                 return False
 
-            # always_free的job不需要检查active_jobs
-            if not job_info.always_free:
-                # 检查设备上是否是这个job
-                if device_key not in self.active_jobs or self.active_jobs[device_key].job_id != job_id:
-                    job_log = format_job_log(
-                        job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
-                    )
-                    logger.error(f"[DeviceActionManager] Job {job_log} is not the active job for {device_key}")
-                    return False
+            # 检查设备上是否是这个job
+            if device_key not in self.active_jobs or self.active_jobs[device_key].job_id != job_id:
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
+                logger.error(f"[DeviceActionManager] Job {job_log} is not the active job for {device_key}")
+                return False
 
             # 开始执行任务，将状态从READY转换为STARTED
             job_info.status = JobStatus.STARTED
@@ -217,13 +203,6 @@ class DeviceActionManager:
             job_info = self.all_jobs[job_id]
             device_key = job_info.device_action_key
 
-            # always_free的job直接清理，不影响队列
-            if job_info.always_free:
-                job_info.status = JobStatus.ENDED
-                job_info.update_timestamp()
-                del self.all_jobs[job_id]
-                return None
-
             # 移除活跃任务
             if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                 del self.active_jobs[device_key]
@@ -231,9 +210,8 @@ class DeviceActionManager:
                 job_info.update_timestamp()
                 # 从all_jobs中移除已结束的job
                 del self.all_jobs[job_id]
-                # job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                # logger.debug(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
-                pass
+                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
+                logger.info(f"[DeviceActionManager] Job {job_log} ended for {device_key}")
             else:
                 job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
                 logger.warning(f"[DeviceActionManager] Job {job_log} was not active for {device_key}")
@@ -249,20 +227,15 @@ class DeviceActionManager:
                 next_job_log = format_job_log(
                     next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                 )
-                logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
+                logger.info(f"[DeviceActionManager] Next job {next_job_log} can start for {device_key}")
                 return next_job
 
             return None
 
     def get_active_jobs(self) -> List[JobInfo]:
-        """获取所有正在执行的任务(含active_jobs和always_free的STARTED job)"""
+        """获取所有正在执行的任务"""
         with self.lock:
-            jobs = list(self.active_jobs.values())
-            # 补充 always_free 的 STARTED job(它们不在 active_jobs 中)
-            for job in self.all_jobs.values():
-                if job.always_free and job.status == JobStatus.STARTED and job not in jobs:
-                    jobs.append(job)
-            return jobs
+            return list(self.active_jobs.values())
 
     def get_queued_jobs(self) -> List[JobInfo]:
         """获取所有排队中的任务"""
@@ -287,14 +260,6 @@ class DeviceActionManager:
             job_info = self.all_jobs[job_id]
             device_key = job_info.device_action_key
 
-            # always_free的job直接清理
-            if job_info.always_free:
-                job_info.status = JobStatus.ENDED
-                del self.all_jobs[job_id]
-                job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Always-free job {job_log} cancelled")
-                return True
-
             # 如果是正在执行的任务
             if device_key in self.active_jobs and self.active_jobs[device_key].job_id == job_id:
                 # 清理active job状态
@@ -303,7 +268,7 @@ class DeviceActionManager:
                 # 从all_jobs中移除
                 del self.all_jobs[job_id]
                 job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
-                logger.trace(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")
+                logger.info(f"[DeviceActionManager] Active job {job_log} cancelled for {device_key}")
 
                 # 启动下一个任务
                 if device_key in self.device_queues and self.device_queues[device_key]:
@@ -316,7 +281,7 @@ class DeviceActionManager:
                     next_job_log = format_job_log(
                         next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name
                     )
-                    logger.trace(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
+                    logger.info(f"[DeviceActionManager] Next job {next_job_log} can start after cancel")
                 return True
 
             # 如果是排队中的任务
@@ -330,7 +295,7 @@ class DeviceActionManager:
                     job_log = format_job_log(
                         job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name
                     )
-                    logger.trace(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
+                    logger.info(f"[DeviceActionManager] Queued job {job_log} cancelled for {device_key}")
                     return True
 
             job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
@@ -368,18 +333,13 @@ class DeviceActionManager:
         timeout_jobs = []
 
         with self.lock:
-            # 收集所有需要检查的 READY 任务(active_jobs + always_free READY jobs)
-            ready_candidates = list(self.active_jobs.values())
-            for job in self.all_jobs.values():
-                if job.always_free and job.status == JobStatus.READY and job not in ready_candidates:
-                    ready_candidates.append(job)
-
-            ready_jobs_count = sum(1 for job in ready_candidates if job.status == JobStatus.READY)
+            # 统计READY状态的任务数量
+            ready_jobs_count = sum(1 for job in self.active_jobs.values() if job.status == JobStatus.READY)
             if ready_jobs_count > 0:
                 logger.trace(f"[DeviceActionManager] Checking {ready_jobs_count} READY jobs for timeout")  # type: ignore  # noqa: E501
 
             # 找到所有超时的READY任务（只检测，不处理）
-            for job_info in ready_candidates:
+            for job_info in self.active_jobs.values():
                 if job_info.is_ready_timeout():
                     timeout_jobs.append(job_info)
                     job_log = format_job_log(
@@ -466,7 +426,6 @@ class MessageProcessor:
                 async with websockets.connect(
                     self.websocket_url,
                     ssl=ssl_context,
-                    open_timeout=20,
                     ping_interval=WSConfig.ping_interval,
                     ping_timeout=10,
                     additional_headers={
@@ -498,18 +457,6 @@ class MessageProcessor:
             except websockets.exceptions.ConnectionClosed:
                 logger.warning("[MessageProcessor] Connection closed")
                 self.connected = False
-            except TimeoutError:
-                logger.warning(
-                    f"[MessageProcessor] Connection timeout (attempt {self.reconnect_count + 1}), "
-                    f"server may be temporarily unavailable"
-                )
-                self.connected = False
-            except websockets.exceptions.InvalidStatus as e:
-                logger.warning(
-                    f"[MessageProcessor] Server returned unexpected HTTP status {e.response.status_code}, "
-                    f"WebSocket endpoint may not be ready yet"
-                )
-                self.connected = False
             except Exception as e:
                 logger.error(f"[MessageProcessor] Connection error: {str(e)}")
                 logger.error(traceback.format_exc())
@@ -518,19 +465,18 @@ class MessageProcessor:
                 self.websocket = None
 
             # 重连逻辑
-            if not self.is_running:
-                break
-            if self.reconnect_count < WSConfig.max_reconnect_attempts:
+            if self.is_running and self.reconnect_count < WSConfig.max_reconnect_attempts:
                 self.reconnect_count += 1
-                backoff = min(WSConfig.reconnect_interval * (2 ** (self.reconnect_count - 1)), 60)
                 logger.info(
-                    f"[MessageProcessor] Reconnecting in {backoff}s "
+                    f"[MessageProcessor] Reconnecting in {WSConfig.reconnect_interval}s "
                     f"(attempt {self.reconnect_count}/{WSConfig.max_reconnect_attempts})"
                 )
-                await asyncio.sleep(backoff)
-            else:
+                await asyncio.sleep(WSConfig.reconnect_interval)
+            elif self.reconnect_count >= WSConfig.max_reconnect_attempts:
                 logger.error("[MessageProcessor] Max reconnection attempts reached")
                 break
+            else:
+                self.reconnect_count -= 1
 
     async def _message_handler(self):
         """处理接收到的消息"""
@@ -548,12 +494,8 @@ class MessageProcessor:
                         await self._process_message(message_type, message_data)
                     else:
                         if message_type.endswith("_material"):
-                            logger.trace(
-                                f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}"
-                            )
-                            logger.debug(
-                                f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}"
-                            )
+                            logger.trace(f"[MessageProcessor] 收到一条归属 {data.get('edge_session')} 的旧消息：{data}")
+                            logger.debug(f"[MessageProcessor] 跳过了一条归属 {data.get('edge_session')} 的旧消息: {data.get('action')}")
                         else:
                             await self._process_message(message_type, message_data)
                 except json.JSONDecodeError:
@@ -598,7 +540,7 @@ class MessageProcessor:
                         try:
                             message_str = json.dumps(msg, ensure_ascii=False)
                             await self.websocket.send(message_str)
-                            # logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
+                            logger.trace(f"[MessageProcessor] Message sent: {msg.get('action', 'unknown')}")  # type: ignore  # noqa: E501
                         except Exception as e:
                             logger.error(f"[MessageProcessor] Failed to send message: {str(e)}")
                             logger.error(traceback.format_exc())
@@ -623,7 +565,7 @@ class MessageProcessor:
 
     async def _process_message(self, message_type: str, message_data: Dict[str, Any]):
         """处理收到的消息"""
-        logger.trace(f"[MessageProcessor] Processing message: {message_type}")
+        logger.debug(f"[MessageProcessor] Processing message: {message_type}")
 
         try:
             if message_type == "pong":
@@ -661,24 +603,6 @@ class MessageProcessor:
         if host_node:
             host_node.handle_pong_response(pong_data)
 
-    def _check_action_always_free(self, device_id: str, action_name: str) -> bool:
-        """检查该action是否标记为always_free，通过HostNode统一的_action_value_mappings查找"""
-        try:
-            host_node = HostNode.get_instance(0)
-            if not host_node:
-                return False
-            # noinspection PyProtectedMember
-            action_mappings = host_node._action_value_mappings.get(device_id)
-            if not action_mappings:
-                return False
-            # 尝试直接匹配或 auto- 前缀匹配
-            for key in [action_name, f"auto-{action_name}"]:
-                if key in action_mappings:
-                    return action_mappings[key].get("always_free", False)
-            return False
-        except Exception:
-            return False
-
     async def _handle_query_action_state(self, data: Dict[str, Any]):
         """处理query_action_state消息"""
         device_id = data.get("device_id", "")
@@ -693,9 +617,6 @@ class MessageProcessor:
 
         device_action_key = f"/devices/{device_id}/{action_name}"
 
-        # 检查action是否为always_free
-        action_always_free = self._check_action_always_free(device_id, action_name)
-
         # 创建任务信息
         job_info = JobInfo(
             job_id=job_id,
@@ -705,7 +626,6 @@ class MessageProcessor:
             device_action_key=device_action_key,
             status=JobStatus.QUEUE,
             start_time=time.time(),
-            always_free=action_always_free,
         )
 
         # 添加到设备管理器
@@ -717,13 +637,13 @@ class MessageProcessor:
             await self._send_action_state_response(
                 device_id, action_name, task_id, job_id, "query_action_status", True, 0
             )
-            logger.trace(f"[MessageProcessor] Job {job_log} can start immediately")
+            logger.info(f"[MessageProcessor] Job {job_log} can start immediately")
         else:
             # 需要排队
             await self._send_action_state_response(
                 device_id, action_name, task_id, job_id, "query_action_status", False, 10
             )
-            logger.trace(f"[MessageProcessor] Job {job_log} queued")
+            logger.info(f"[MessageProcessor] Job {job_log} queued")
 
             # 通知QueueProcessor有新的队列更新
             if self.queue_processor:
@@ -732,8 +652,6 @@ class MessageProcessor:
     async def _handle_job_start(self, data: Dict[str, Any]):
         """处理job_start消息"""
         try:
-            if not data.get("sample_material"):
-                data["sample_material"] = {}
             req = JobAddReq(**data)
 
             job_log = format_job_log(req.job_id, req.task_id, req.device_id, req.action)
@@ -765,7 +683,6 @@ class MessageProcessor:
                 queue_item,
                 action_type=req.action_type,
                 action_kwargs=req.action_args,
-                sample_material=req.sample_material,
                 server_info=req.server_info,
             )
 
@@ -930,7 +847,9 @@ class MessageProcessor:
                         device_action_groups[key_add] = []
                     device_action_groups[key_add].append(item["uuid"])
 
-                    logger.info(f"[资源同步] 跨站Transfer: {item['uuid'][:8]} from {device_old_id} to {device_id}")
+                    logger.info(
+                        f"[MessageProcessor] Resource migrated: {item['uuid'][:8]} from {device_old_id} to {device_id}"
+                    )
                 else:
                     # 正常update
                     key = (device_id, "update")
@@ -944,13 +863,11 @@ class MessageProcessor:
                     device_action_groups[key] = []
                 device_action_groups[key].append(item["uuid"])
 
-        logger.trace(
-            f"[资源同步] 动作 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}"
-        )
+        logger.info(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")
 
         # 为每个(device_id, action)创建独立的更新线程
         for (device_id, actual_action), items in device_action_groups.items():
-            logger.trace(f"[资源同步] {device_id} 物料动作 {actual_action} 数量: {len(items)}")
+            logger.info(f"设备 {device_id} 物料更新 {actual_action} 数量: {len(items)}")
 
             def _notify_resource_tree(dev_id, act, item_list):
                 try:
@@ -985,44 +902,42 @@ class MessageProcessor:
     async def _handle_request_restart(self, data: Dict[str, Any]):
         """
         处理重启请求
-
+        
         当LabGo发送request_restart时，执行清理并触发重启
         """
         reason = data.get("reason", "unknown")
         delay = data.get("delay", 2)  # 默认延迟2秒
         logger.info(f"[MessageProcessor] Received restart request, reason: {reason}, delay: {delay}s")
-
+        
         # 发送确认消息
         if self.websocket_client:
-            await self.websocket_client.send_message(
-                {"action": "restart_acknowledged", "data": {"reason": reason, "delay": delay}}
-            )
-
+            await self.websocket_client.send_message({
+                "action": "restart_acknowledged",
+                "data": {"reason": reason, "delay": delay}
+            })
+        
         # 设置全局重启标志
         import unilabos.app.main as main_module
-
         main_module._restart_requested = True
         main_module._restart_reason = reason
-
+        
         # 延迟后执行清理
         await asyncio.sleep(delay)
-
+        
         # 在新线程中执行清理，避免阻塞当前事件循环
         def do_cleanup():
             import time
-
             time.sleep(0.5)  # 给当前消息处理完成的时间
             logger.info(f"[MessageProcessor] Starting cleanup for restart, reason: {reason}")
             try:
                 from unilabos.app.utils import cleanup_for_restart
-
                 if cleanup_for_restart():
                     logger.info("[MessageProcessor] Cleanup successful, main() will restart")
                 else:
                     logger.error("[MessageProcessor] Cleanup failed")
             except Exception as e:
                 logger.error(f"[MessageProcessor] Error during cleanup: {e}")
-
+        
         cleanup_thread = threading.Thread(target=do_cleanup, name="RestartCleanupThread", daemon=True)
         cleanup_thread.start()
         logger.info(f"[MessageProcessor] Restart cleanup scheduled")
@@ -1198,11 +1113,6 @@ class QueueProcessor:
         logger.debug(f"[QueueProcessor] Sending busy status for {len(queued_jobs)} queued jobs")
 
         for job_info in queued_jobs:
-            # 快照可能已过期：在遍历过程中 end_job() 可能已将此 job 移至 READY，
-            # 此时不应再发送 busy/need_more，否则会覆盖已发出的 free=True 通知
-            if job_info.status != JobStatus.QUEUE:
-                continue
-
             message = {
                 "action": "report_action_state",
                 "data": {
@@ -1218,7 +1128,7 @@ class QueueProcessor:
             success = self.message_processor.send_message(message)
             job_log = format_job_log(job_info.job_id, job_info.task_id, job_info.device_id, job_info.action_name)
             if success:
-                logger.trace(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
+                logger.debug(f"[QueueProcessor] Sent busy/need_more for queued job {job_log}")
             else:
                 logger.warning(f"[QueueProcessor] Failed to send busy status for job {job_log}")
 
@@ -1241,7 +1151,7 @@ class QueueProcessor:
             job_info.action_name,
         )
 
-        logger.trace(f"[QueueProcessor] Job {job_log} completed with status: {status}")
+        logger.info(f"[QueueProcessor] Job {job_log} completed with status: {status}")
 
         # 结束任务，获取下一个可执行的任务
         next_job = self.device_manager.end_job(job_id)
@@ -1261,8 +1171,8 @@ class QueueProcessor:
                 },
             }
             self.message_processor.send_message(message)
-            # next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
-            # logger.debug(f"[QueueProcessor] Notified next job {next_job_log} can start")
+            next_job_log = format_job_log(next_job.job_id, next_job.task_id, next_job.device_id, next_job.action_name)
+            logger.info(f"[QueueProcessor] Notified next job {next_job_log} can start")
 
             # 立即触发下一轮状态检查
             self.notify_queue_update()
@@ -1384,7 +1294,7 @@ class WebSocketClient(BaseCommunicationClient):
             },
         }
         self.message_processor.send_message(message)
-        # logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
 
     def publish_job_status(
         self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None
@@ -1404,7 +1314,7 @@ class WebSocketClient(BaseCommunicationClient):
                 except (KeyError, AttributeError):
                     logger.warning(f"[WebSocketClient] Failed to remove job {item.job_id} from HostNode status")
 
-            # logger.debug(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")
+            logger.info(f"[WebSocketClient] Intercepting final status for job_id: {item.job_id} - {status}")
 
             # 通知队列处理器job完成（包括timeout的job）
             self.queue_processor.handle_job_completed(item.job_id, status)
@@ -1465,17 +1375,15 @@ class WebSocketClient(BaseCommunicationClient):
         # 收集设备信息
         devices = []
         machine_name = BasicConfig.machine_name
-
+        
         try:
             host_node = HostNode.get_instance(0)
             if host_node:
                 # 获取设备信息
                 for device_id, namespace in host_node.devices_names.items():
-                    device_key = (
-                        f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
-                    )
+                    device_key = f"{namespace}/{device_id}" if namespace.startswith("/") else f"/{namespace}/{device_id}"
                     is_online = device_key in host_node._online_devices
-
+                    
                     # 获取设备的动作信息
                     actions = {}
                     for action_id, client in host_node._action_clients.items():
@@ -1486,18 +1394,16 @@ class WebSocketClient(BaseCommunicationClient):
                                 "action_path": action_id,
                                 "action_type": str(type(client).__name__),
                             }
-
-                    devices.append(
-                        {
-                            "device_id": device_id,
-                            "namespace": namespace,
-                            "device_key": device_key,
-                            "is_online": is_online,
-                            "machine_name": host_node.device_machine_names.get(device_id, machine_name),
-                            "actions": actions,
-                        }
-                    )
-
+                    
+                    devices.append({
+                        "device_id": device_id,
+                        "namespace": namespace,
+                        "device_key": device_key,
+                        "is_online": is_online,
+                        "machine_name": host_node.device_machine_names.get(device_id, machine_name),
+                        "actions": actions,
+                    })
+                
                 logger.info(f"[WebSocketClient] Collected {len(devices)} devices for host_ready")
         except Exception as e:
             logger.warning(f"[WebSocketClient] Error collecting device info: {e}")

unilabos/compile/pump_protocol.py

@@ -95,29 +95,8 @@ def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
     return total_volume
 
 
-def is_integrated_pump(node_class: str, node_name: str = "") -> bool:
-    """
-    判断是否为泵阀一体设备
-    """
-    class_lower = (node_class or "").lower()
-    name_lower = (node_name or "").lower()
-
-    if "pump" not in class_lower and "pump" not in name_lower:
-        return False
-
-    integrated_markers = [
-        "valve",
-        "pump_valve",
-        "pumpvalve",
-        "integrated",
-        "transfer_pump",
-    ]
-
-    for marker in integrated_markers:
-        if marker in class_lower or marker in name_lower:
-            return True
-
-    return False
+def is_integrated_pump(node_name):
+    return "pump" in node_name and "valve" in node_name
 
 
 def find_connected_pump(G, valve_node):
@@ -207,9 +186,7 @@ def build_pump_valve_maps(G, pump_backbone):
     debug_print(f"🔧 过滤后的骨架: {filtered_backbone}")
 
     for node in filtered_backbone:
-        node_data = G.nodes.get(node, {})
-        node_class = node_data.get("class", "") or ""
-        if is_integrated_pump(node_class, node):
+        if is_integrated_pump(G.nodes[node]["class"]):
             pumps_from_node[node] = node
             valve_from_node[node] = node
             debug_print(f"  - 集成泵-阀: {node}")

unilabos/config/config.py

@@ -22,8 +22,6 @@ class BasicConfig:
     startup_json_path = None  # 填写绝对路径
     disable_browser = False  # 禁止浏览器自动打开
     port = 8002  # 本地HTTP服务
-    check_mode = False  # CI 检查模式，用于验证 registry 导入和文件一致性
-    test_mode = False  # 测试模式，所有动作不实际执行，返回模拟结果
     # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
     log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
 
@@ -146,5 +144,5 @@ def load_config(config_path=None):
             traceback.print_exc()
             exit(1)
     else:
-        config_path = os.path.join(os.path.dirname(__file__), "example_config.py")
+        config_path = os.path.join(os.path.dirname(__file__), "local_config.py")
         load_config(config_path)

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/devices/motor/ZDT_X42.py

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

unilabos/devices/ros_dev/liquid_handler_joint_publisher.py

@@ -19,11 +19,10 @@ from rclpy.node import Node
 import re
 
 class LiquidHandlerJointPublisher(BaseROS2DeviceNode):
-    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", registry_name: str = "lh_joint_publisher", **kwargs):
+    def __init__(self,resources_config:list, resource_tracker, rate=50, device_id:str = "lh_joint_publisher", **kwargs):
         super().__init__(
             driver_instance=self,
             device_id=device_id,
-            registry_name=registry_name,
             status_types={},
             action_value_mappings={},
             hardware_interface={},

unilabos/devices/separator/chinwe.py

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

unilabos/devices/separator/xkc_sensor.py

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

unilabos/devices/virtual/virtual_transferpump.py

@@ -15,35 +15,35 @@ class VirtualPumpMode(Enum):
 
 class VirtualTransferPump:
     """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件 🚰"""
-
+    
     _ros_node: BaseROS2DeviceNode
-
+    
     def __init__(self, device_id: str = None, config: dict = None, **kwargs):
         """
         初始化虚拟转移泵
-
+        
         Args:
             device_id: 设备ID
             config: 配置字典，包含max_volume, port等参数
             **kwargs: 其他参数，确保兼容性
         """
         self.device_id = device_id or "virtual_transfer_pump"
-
+        
         # 从config或kwargs中获取参数，确保类型正确
         if config:
-            self.max_volume = float(config.get("max_volume", 25.0))
-            self.port = config.get("port", "VIRTUAL")
+            self.max_volume = float(config.get('max_volume', 25.0))
+            self.port = config.get('port', 'VIRTUAL')
         else:
-            self.max_volume = float(kwargs.get("max_volume", 25.0))
-            self.port = kwargs.get("port", "VIRTUAL")
-
-        self._transfer_rate = float(kwargs.get("transfer_rate", 0))
-        self.mode = kwargs.get("mode", VirtualPumpMode.Normal)
-
+            self.max_volume = float(kwargs.get('max_volume', 25.0))
+            self.port = kwargs.get('port', 'VIRTUAL')
+        
+        self._transfer_rate = float(kwargs.get('transfer_rate', 0))
+        self.mode = kwargs.get('mode', VirtualPumpMode.Normal)
+        
         # 状态变量 - 确保都是正确类型
         self._status = "Idle"
         self._position = 0.0  # float
-        self._max_velocity = 5.0  # float
+        self._max_velocity = 5.0  # float 
         self._current_volume = 0.0  # float
 
         # 🚀 新增：快速模式设置 - 大幅缩短执行时间
@@ -52,16 +52,14 @@ class VirtualTransferPump:
         self._fast_dispense_time = 1.0  # 快速喷射时间（秒）
 
         self.logger = logging.getLogger(f"VirtualTransferPump.{self.device_id}")
-
+        
         print(f"🚰 === 虚拟转移泵 {self.device_id} 已创建 === ✨")
-        print(
-            f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s"
-        )
+        print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
         print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
-
+    
     def post_init(self, ros_node: BaseROS2DeviceNode):
         self._ros_node = ros_node
-
+    
     async def initialize(self) -> bool:
         """初始化虚拟泵 🚀"""
         self.logger.info(f"🔧 初始化虚拟转移泵 {self.device_id} ✨")
@@ -70,33 +68,33 @@ class VirtualTransferPump:
         self._current_volume = 0.0
         self.logger.info(f"✅ 转移泵 {self.device_id} 初始化完成 🚰")
         return True
-
+    
     async def cleanup(self) -> bool:
         """清理虚拟泵 🧹"""
         self.logger.info(f"🧹 清理虚拟转移泵 {self.device_id} 🔚")
         self._status = "Idle"
         self.logger.info(f"✅ 转移泵 {self.device_id} 清理完成 💤")
         return True
-
+    
     # 基本属性
     @property
     def status(self) -> str:
         return self._status
-
+    
     @property
     def position(self) -> float:
         """当前柱塞位置 (ml) 📍"""
         return self._position
-
+    
     @property
     def current_volume(self) -> float:
         """当前注射器中的体积 (ml) 💧"""
         return self._current_volume
-
+    
     @property
     def max_velocity(self) -> float:
         return self._max_velocity
-
+    
     @property
     def transfer_rate(self) -> float:
         return self._transfer_rate
@@ -105,17 +103,17 @@ class VirtualTransferPump:
         """设置最大速度 (ml/s) 🌊"""
         self._max_velocity = max(0.1, min(50.0, velocity))  # 限制在合理范围内
         self.logger.info(f"🌊 设置最大速度为 {self._max_velocity} mL/s")
-
+    
     def get_status(self) -> str:
         """获取泵状态 📋"""
         return self._status
-
+    
     async def _simulate_operation(self, duration: float):
         """模拟操作延时 ⏱️"""
         self._status = "Busy"
         await self._ros_node.sleep(duration)
         self._status = "Idle"
-
+    
     def _calculate_duration(self, volume: float, velocity: float = None) -> float:
         """
         计算操作持续时间 ⏰
@@ -123,10 +121,10 @@ class VirtualTransferPump:
         """
         if velocity is None:
             velocity = self._max_velocity
-
+        
         # 📊 计算理论时间（用于日志显示）
         theoretical_duration = abs(volume) / velocity
-
+        
         # 🚀 如果启用快速模式，使用固定的快速时间
         if self._fast_mode:
             # 根据操作类型选择快速时间
@@ -134,13 +132,13 @@ class VirtualTransferPump:
                 actual_duration = self._fast_move_time
             else:  # 很小的操作
                 actual_duration = 0.5
-
+            
             self.logger.debug(f"⚡ 快速模式: 理论时间 {theoretical_duration:.2f}s → 实际时间 {actual_duration:.2f}s")
             return actual_duration
         else:
             # 正常模式使用理论时间
             return theoretical_duration
-
+    
     def _calculate_display_duration(self, volume: float, velocity: float = None) -> float:
         """
         计算显示用的持续时间（用于日志） 📊
@@ -149,16 +147,16 @@ class VirtualTransferPump:
         if velocity is None:
             velocity = self._max_velocity
         return abs(volume) / velocity
-
+    
     # 新的set_position方法 - 专门用于SetPumpPosition动作
     async def set_position(self, position: float, max_velocity: float = None):
         """
         移动到绝对位置 - 专门用于SetPumpPosition动作 🎯
-
+        
         Args:
             position (float): 目标位置 (ml)
             max_velocity (float): 移动速度 (ml/s)
-
+        
         Returns:
             dict: 符合SetPumpPosition.action定义的结果
         """
@@ -166,19 +164,19 @@ class VirtualTransferPump:
             # 验证并转换参数
             target_position = float(position)
             velocity = float(max_velocity) if max_velocity is not None else self._max_velocity
-
+            
             # 限制位置在有效范围内
             target_position = max(0.0, min(float(self.max_volume), target_position))
-
+            
             # 计算移动距离
             volume_to_move = abs(target_position - self._position)
-
+            
             # 📊 计算显示用的时间（用于日志）
             display_duration = self._calculate_display_duration(volume_to_move, velocity)
-
+            
             # ⚡ 计算实际执行时间（快速模式）
             actual_duration = self._calculate_duration(volume_to_move, velocity)
-
+            
             # 🎯 确定操作类型和emoji
             if target_position > self._position:
                 operation_type = "吸液"
@@ -189,34 +187,28 @@ class VirtualTransferPump:
             else:
                 operation_type = "保持"
                 operation_emoji = "📍"
-
+            
             self.logger.info(f"🎯 SET_POSITION: {operation_type} {operation_emoji}")
-            self.logger.info(
-                f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)"
-            )
+            self.logger.info(f"  📍 位置: {self._position:.2f}mL → {target_position:.2f}mL (移动 {volume_to_move:.2f}mL)")
             self.logger.info(f"  🌊 速度: {velocity:.2f} mL/s")
             self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+            
             if self._fast_mode:
                 self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+            
             # 🚀 模拟移动过程
             if volume_to_move > 0.01:  # 只有当移动距离足够大时才显示进度
                 start_position = self._position
                 steps = 5 if actual_duration > 0.5 else 2  # 根据实际时间调整步数
                 step_duration = actual_duration / steps
-
+                
                 self.logger.info(f"🚀 开始{operation_type}... {operation_emoji}")
-
+                
                 for i in range(steps + 1):
                     # 计算当前位置和进度
                     progress = (i / steps) * 100 if steps > 0 else 100
-                    current_pos = (
-                        start_position + (target_position - start_position) * (i / steps)
-                        if steps > 0
-                        else target_position
-                    )
-
+                    current_pos = start_position + (target_position - start_position) * (i / steps) if steps > 0 else target_position
+                    
                     # 更新状态
                     if i < steps:
                         self._status = f"{operation_type}中"
@@ -224,10 +216,10 @@ class VirtualTransferPump:
                     else:
                         self._status = "Idle"
                         status_emoji = "✅"
-
+                    
                     self._position = current_pos
                     self._current_volume = current_pos
-
+                    
                     # 显示进度（每25%或最后一步）
                     if i == 0:
                         self.logger.debug(f"  🔄 {operation_type}开始: {progress:.0f}%")
@@ -235,7 +227,7 @@ class VirtualTransferPump:
                         self.logger.debug(f"  🔄 {operation_type}进度: {progress:.0f}%")
                     elif i == steps:
                         self.logger.info(f"  ✅ {operation_type}完成: {progress:.0f}% | 当前位置: {current_pos:.2f}mL")
-
+                    
                     # 等待一小步时间
                     if i < steps and step_duration > 0:
                         await self._ros_node.sleep(step_duration)
@@ -244,27 +236,25 @@ class VirtualTransferPump:
                 self._position = target_position
                 self._current_volume = target_position
                 self.logger.info(f"  📍 微调完成: {target_position:.2f}mL")
-
+        
             # 确保最终位置准确
             self._position = target_position
             self._current_volume = target_position
             self._status = "Idle"
-
+            
             # 📊 最终状态日志
             if volume_to_move > 0.01:
-                self.logger.info(
-                    f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL"
-                )
-
+                self.logger.info(f"🎉 SET_POSITION 完成! 📍 最终位置: {self._position:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
+            
             # 返回符合action定义的结果
             return {
                 "success": True,
                 "message": f"✅ 成功移动到位置 {self._position:.2f}mL ({operation_type})",
                 "final_position": self._position,
                 "final_volume": self._current_volume,
-                "operation_type": operation_type,
+                "operation_type": operation_type
             }
-
+            
         except Exception as e:
             error_msg = f"❌ 设置位置失败: {str(e)}"
             self.logger.error(error_msg)
@@ -272,136 +262,134 @@ class VirtualTransferPump:
                 "success": False,
                 "message": error_msg,
                 "final_position": self._position,
-                "final_volume": self._current_volume,
+                "final_volume": self._current_volume
             }
-
+    
     # 其他泵操作方法
     async def pull_plunger(self, volume: float, velocity: float = None):
         """
         拉取柱塞（吸液） 📥
-
+        
         Args:
             volume (float): 要拉取的体积 (ml)
             velocity (float): 拉取速度 (ml/s)
         """
         new_position = min(self.max_volume, self._position + volume)
         actual_volume = new_position - self._position
-
+        
         if actual_volume <= 0:
             self.logger.warning("⚠️ 无法吸液 - 已达到最大容量")
             return
-
+        
         display_duration = self._calculate_display_duration(actual_volume, velocity)
         actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
         self.logger.info(f"📥 开始吸液: {actual_volume:.2f}mL")
         self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
         self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
         if self._fast_mode:
             self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
         await self._simulate_operation(actual_duration)
-
+        
         self._position = new_position
         self._current_volume = new_position
-
+        
         self.logger.info(f"✅ 吸液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     async def push_plunger(self, volume: float, velocity: float = None):
         """
         推出柱塞（排液） 📤
-
+        
         Args:
             volume (float): 要推出的体积 (ml)
             velocity (float): 推出速度 (ml/s)
         """
         new_position = max(0, self._position - volume)
         actual_volume = self._position - new_position
-
+        
         if actual_volume <= 0:
             self.logger.warning("⚠️ 无法排液 - 已达到最小容量")
             return
-
+        
         display_duration = self._calculate_display_duration(actual_volume, velocity)
         actual_duration = self._calculate_duration(actual_volume, velocity)
-
+        
         self.logger.info(f"📤 开始排液: {actual_volume:.2f}mL")
         self.logger.info(f"  📍 位置: {self._position:.2f}mL → {new_position:.2f}mL")
         self.logger.info(f"  ⏰ 预计时间: {display_duration:.2f}s")
-
+        
         if self._fast_mode:
             self.logger.info(f"  ⚡ 快速模式: 实际用时 {actual_duration:.2f}s")
-
+        
         await self._simulate_operation(actual_duration)
-
+        
         self._position = new_position
         self._current_volume = new_position
-
+        
         self.logger.info(f"✅ 排液完成: {actual_volume:.2f}mL | 💧 当前体积: {self._current_volume:.2f}mL")
 
     # 便捷操作方法
     async def aspirate(self, volume: float, velocity: float = None):
         """吸液操作 📥"""
         await self.pull_plunger(volume, velocity)
-
+    
     async def dispense(self, volume: float, velocity: float = None):
         """排液操作 📤"""
         await self.push_plunger(volume, velocity)
-
+    
     async def transfer(self, volume: float, aspirate_velocity: float = None, dispense_velocity: float = None):
         """转移操作（先吸后排） 🔄"""
         self.logger.info(f"🔄 开始转移操作: {volume:.2f}mL")
-
+        
         # 吸液
         await self.aspirate(volume, aspirate_velocity)
-
+        
         # 短暂停顿
         self.logger.debug("⏸️ 短暂停顿...")
         await self._ros_node.sleep(0.1)
-
+        
         # 排液
         await self.dispense(volume, dispense_velocity)
-
+    
     async def empty_syringe(self, velocity: float = None):
         """清空注射器"""
         await self.set_position(0, velocity)
-
+    
     async def fill_syringe(self, velocity: float = None):
         """充满注射器"""
         await self.set_position(self.max_volume, velocity)
-
+    
     async def stop_operation(self):
         """停止当前操作"""
         self._status = "Idle"
         self.logger.info("Operation stopped")
-
+    
     # 状态查询方法
     def get_position(self) -> float:
         """获取当前位置"""
         return self._position
-
+    
     def get_current_volume(self) -> float:
         """获取当前体积"""
         return self._current_volume
-
+    
     def get_remaining_capacity(self) -> float:
         """获取剩余容量"""
         return self.max_volume - self._current_volume
-
+    
     def is_empty(self) -> bool:
         """检查是否为空"""
         return self._current_volume <= 0.01  # 允许小量误差
-
+    
     def is_full(self) -> bool:
         """检查是否已满"""
         return self._current_volume >= (self.max_volume - 0.01)  # 允许小量误差
-
+    
     def __str__(self):
-        return (
-            f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
-        )
-
+        return f"VirtualTransferPump({self.device_id}: {self._current_volume:.2f}/{self.max_volume} ml, {self._status})"
+    
     def __repr__(self):
         return self.__str__()
 
@@ -410,20 +398,20 @@ class VirtualTransferPump:
 async def demo():
     """虚拟泵使用示例"""
     pump = VirtualTransferPump("demo_pump", {"max_volume": 50.0})
-
+    
     await pump.initialize()
-
+    
     print(f"Initial state: {pump}")
-
+    
     # 测试set_position方法
     result = await pump.set_position(10.0, max_velocity=2.0)
     print(f"Set position result: {result}")
     print(f"After setting position to 10ml: {pump}")
-
+    
     # 吸液测试
     await pump.aspirate(5.0, velocity=2.0)
     print(f"After aspirating 5ml: {pump}")
-
+    
     # 清空测试
     result = await pump.set_position(0.0)
     print(f"Empty result: {result}")

unilabos/devices/virtual/workbench.py

@@ -1,759 +0,0 @@
-"""
-Virtual Workbench Device - 模拟工作台设备
-包含：
-- 1个机械臂 (每次操作3s, 独占锁)
-- 3个加热台 (每次加热10s, 可并行)
-
-工作流程：
-1. A1-A5 物料同时启动，竞争机械臂
-2. 机械臂将物料移动到空闲加热台
-3. 加热完成后，机械臂将物料移动到C1-C5
-
-注意：调用来自线程池，使用 threading.Lock 进行同步
-"""
-
-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_extensions import TypedDict
-
-from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
-from unilabos.utils.decorator import not_action, always_free
-from unilabos.resources.resource_tracker import SampleUUIDsType, LabSample, RETURN_UNILABOS_SAMPLES
-
-
-# ============ TypedDict 返回类型定义 ============
-
-
-class MoveToHeatingStationResult(TypedDict):
-    """move_to_heating_station 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    material_number: int
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-class StartHeatingResult(TypedDict):
-    """start_heating 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    material_number: int
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-class MoveToOutputResult(TypedDict):
-    """move_to_output 返回类型"""
-
-    success: bool
-    station_id: int
-    material_id: str
-    unilabos_samples: List[LabSample]
-
-
-class PrepareMaterialsResult(TypedDict):
-    """prepare_materials 返回类型 - 批量准备物料"""
-
-    success: bool
-    count: int
-    material_1: int  # 物料编号1
-    material_2: int  # 物料编号2
-    material_3: int  # 物料编号3
-    material_4: int  # 物料编号4
-    material_5: int  # 物料编号5
-    message: str
-    unilabos_samples: List[LabSample]
-
-
-# ============ 状态枚举 ============
-
-
-class HeatingStationState(Enum):
-    """加热台状态枚举"""
-
-    IDLE = "idle"  # 空闲
-    OCCUPIED = "occupied"  # 已放置物料，等待加热
-    HEATING = "heating"  # 加热中
-    COMPLETED = "completed"  # 加热完成，等待取走
-
-
-class ArmState(Enum):
-    """机械臂状态枚举"""
-
-    IDLE = "idle"  # 空闲
-    BUSY = "busy"  # 工作中
-
-
-@dataclass
-class HeatingStation:
-    """加热台数据结构"""
-
-    station_id: int
-    state: HeatingStationState = HeatingStationState.IDLE
-    current_material: Optional[str] = None  # 当前物料 (如 "A1", "A2")
-    material_number: Optional[int] = None  # 物料编号 (1-5)
-    heating_start_time: Optional[float] = None
-    heating_progress: float = 0.0
-
-
-class VirtualWorkbench:
-    """
-    Virtual Workbench Device - 虚拟工作台设备
-
-    模拟一个包含1个机械臂和3个加热台的工作站
-    - 机械臂操作耗时3秒，同一时间只能执行一个操作
-    - 加热台加热耗时10秒，3个加热台可并行工作
-
-    工作流:
-    1. 物料A1-A5并发启动（线程池），竞争机械臂使用权
-    2. 获取机械臂后，查找空闲加热台
-    3. 机械臂将物料放入加热台，开始加热
-    4. 加热完成后，机械臂将物料移动到目标位置Cn
-    """
-
-    _ros_node: BaseROS2DeviceNode
-
-    # 配置常量
-    ARM_OPERATION_TIME: float = 2  # 机械臂操作时间(秒)
-    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):
-        # 处理可能的不同调用方式
-        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 "virtual_workbench"
-        self.config = config or {}
-
-        self.logger = logging.getLogger(f"VirtualWorkbench.{self.device_id}")
-        self.data: Dict[str, Any] = {}
-
-        # 从config中获取可配置参数
-        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))
-
-        # 机械臂状态和锁 (使用threading.Lock)
-        self._arm_lock = Lock()
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task: Optional[str] = None
-
-        # 加热台状态 (station_id -> HeatingStation) - 立即初始化，不依赖initialize()
-        self._heating_stations: Dict[int, HeatingStation] = {
-            i: HeatingStation(station_id=i) for i in range(1, self.NUM_HEATING_STATIONS + 1)
-        }
-        self._stations_lock = RLock()  # 可重入锁，保护加热台状态
-
-        # 任务追踪
-        self._active_tasks: Dict[str, Dict[str, Any]] = {}  # material_id -> task_info
-        self._tasks_lock = Lock()
-
-        # 处理其他kwargs参数
-        skip_keys = {"arm_operation_time", "heating_time", "num_heating_stations"}
-        for key, value in kwargs.items():
-            if key not in skip_keys and not hasattr(self, key):
-                setattr(self, key, value)
-
-        self.logger.info(f"=== 虚拟工作台 {self.device_id} 已创建 ===")
-        self.logger.info(
-            f"机械臂操作时间: {self.ARM_OPERATION_TIME}s | "
-            f"加热时间: {self.HEATING_TIME}s | "
-            f"加热台数量: {self.NUM_HEATING_STATIONS}"
-        )
-
-    @not_action
-    def post_init(self, ros_node: BaseROS2DeviceNode):
-        """ROS节点初始化后回调"""
-        self._ros_node = ros_node
-
-    @not_action
-    def initialize(self) -> bool:
-        """初始化虚拟工作台"""
-        self.logger.info(f"初始化虚拟工作台 {self.device_id}")
-
-        # 重置加热台状态 (已在__init__中创建，这里重置为初始状态)
-        with self._stations_lock:
-            for station in self._heating_stations.values():
-                station.state = HeatingStationState.IDLE
-                station.current_material = None
-                station.material_number = None
-                station.heating_progress = 0.0
-
-        # 初始化状态
-        self.data.update(
-            {
-                "status": "Ready",
-                "arm_state": ArmState.IDLE.value,
-                "arm_current_task": None,
-                "heating_stations": self._get_stations_status(),
-                "active_tasks_count": 0,
-                "message": "工作台就绪",
-            }
-        )
-
-        self.logger.info(f"工作台初始化完成: {self.NUM_HEATING_STATIONS}个加热台就绪")
-        return True
-
-    @not_action
-    def cleanup(self) -> bool:
-        """清理虚拟工作台"""
-        self.logger.info(f"清理虚拟工作台 {self.device_id}")
-
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task = None
-
-        with self._stations_lock:
-            self._heating_stations.clear()
-
-        with self._tasks_lock:
-            self._active_tasks.clear()
-
-        self.data.update(
-            {
-                "status": "Offline",
-                "arm_state": ArmState.IDLE.value,
-                "heating_stations": {},
-                "message": "工作台已关闭",
-            }
-        )
-        return True
-
-    def _get_stations_status(self) -> Dict[int, Dict[str, Any]]:
-        """获取所有加热台状态"""
-        with self._stations_lock:
-            return {
-                station_id: {
-                    "state": station.state.value,
-                    "current_material": station.current_material,
-                    "material_number": station.material_number,
-                    "heating_progress": station.heating_progress,
-                }
-                for station_id, station in self._heating_stations.items()
-            }
-
-    def _update_data_status(self, message: Optional[str] = None):
-        """更新状态数据"""
-        self.data.update(
-            {
-                "arm_state": self._arm_state.value,
-                "arm_current_task": self._arm_current_task,
-                "heating_stations": self._get_stations_status(),
-                "active_tasks_count": len(self._active_tasks),
-            }
-        )
-        if message:
-            self.data["message"] = message
-
-    def _find_available_heating_station(self) -> Optional[int]:
-        """查找空闲的加热台
-
-        Returns:
-            空闲加热台ID，如果没有则返回None
-        """
-        with self._stations_lock:
-            for station_id, station in self._heating_stations.items():
-                if station.state == HeatingStationState.IDLE:
-                    return station_id
-        return None
-
-    def _acquire_arm(self, task_description: str) -> bool:
-        """获取机械臂使用权（阻塞直到获取）
-
-        Args:
-            task_description: 任务描述，用于日志
-
-        Returns:
-            是否成功获取
-        """
-        self.logger.info(f"[{task_description}] 等待获取机械臂...")
-
-        # 阻塞等待获取锁
-        self._arm_lock.acquire()
-
-        self._arm_state = ArmState.BUSY
-        self._arm_current_task = task_description
-        self._update_data_status(f"机械臂执行: {task_description}")
-
-        self.logger.info(f"[{task_description}] 成功获取机械臂使用权")
-        return True
-
-    def _release_arm(self):
-        """释放机械臂"""
-        task = self._arm_current_task
-        self._arm_state = ArmState.IDLE
-        self._arm_current_task = None
-        self._arm_lock.release()
-        self._update_data_status(f"机械臂已释放 (完成: {task})")
-        self.logger.info(f"机械臂已释放 (完成: {task})")
-
-    def prepare_materials(
-        self,
-        sample_uuids: SampleUUIDsType,
-        count: int = 5,
-    ) -> PrepareMaterialsResult:
-        """
-        批量准备物料 - 虚拟起始节点
-
-        作为工作流的起始节点，生成指定数量的物料编号供后续节点使用。
-        输出5个handle (material_1 ~ material_5)，分别对应实验1~5。
-
-        Args:
-            count: 待生成的物料数量，默认5 (生成 A1-A5)
-
-        Returns:
-            PrepareMaterialsResult: 包含 material_1 ~ material_5 用于传递给 move_to_heating_station
-        """
-        # 生成物料列表 A1 - A{count}
-        materials = [i for i in range(1, count + 1)]
-
-        self.logger.info(f"[准备物料] 生成 {count} 个物料: " f"A1-A{count} -> material_1~material_{count}")
-
-        return {
-            "success": True,
-            "count": count,
-            "material_1": materials[0] if len(materials) > 0 else 0,
-            "material_2": materials[1] if len(materials) > 1 else 0,
-            "material_3": materials[2] if len(materials) > 2 else 0,
-            "material_4": materials[3] if len(materials) > 3 else 0,
-            "material_5": materials[4] if len(materials) > 4 else 0,
-            "message": f"已准备 {count} 个物料: A1-A{count}",
-            "unilabos_samples": [LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for sample_uuid, content in sample_uuids.items()]
-        }
-
-    def move_to_heating_station(
-        self,
-        sample_uuids: SampleUUIDsType,
-        material_number: int,
-    ) -> MoveToHeatingStationResult:
-        """
-        将物料从An位置移动到加热台
-
-        多线程并发调用时，会竞争机械臂使用权，并自动查找空闲加热台
-
-        Args:
-            material_number: 物料编号 (1-5)
-
-        Returns:
-            MoveToHeatingStationResult: 包含 station_id, material_number 等用于传递给下一个节点
-        """
-        # 根据物料编号生成物料ID
-        material_id = f"A{material_number}"
-        task_desc = f"移动{material_id}到加热台"
-        self.logger.info(f"[任务] {task_desc} - 开始执行")
-
-        # 记录任务
-        with self._tasks_lock:
-            self._active_tasks[material_id] = {
-                "status": "waiting_for_arm",
-                "start_time": time.time(),
-            }
-
-        try:
-            # 步骤1: 等待获取机械臂使用权(竞争)
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "waiting_for_arm"
-            self._acquire_arm(task_desc)
-
-            # 步骤2: 查找空闲加热台
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "finding_station"
-            station_id = None
-
-            # 循环等待直到找到空闲加热台
-            while station_id is None:
-                station_id = self._find_available_heating_station()
-                if station_id is None:
-                    self.logger.info(f"[{material_id}] 没有空闲加热台，等待中...")
-                    # 释放机械臂，等待后重试
-                    self._release_arm()
-                    time.sleep(0.5)
-                    self._acquire_arm(task_desc)
-
-            # 步骤3: 占用加热台 - 立即标记为OCCUPIED，防止其他任务选择同一加热台
-            with self._stations_lock:
-                self._heating_stations[station_id].state = HeatingStationState.OCCUPIED
-                self._heating_stations[station_id].current_material = material_id
-                self._heating_stations[station_id].material_number = material_number
-
-            # 步骤4: 模拟机械臂移动操作 (3秒)
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "arm_moving"
-                self._active_tasks[material_id]["assigned_station"] = station_id
-            self.logger.info(f"[{material_id}] 机械臂正在移动到加热台{station_id}...")
-
-            time.sleep(self.ARM_OPERATION_TIME)
-
-            # 步骤5: 放入加热台完成
-            self._update_data_status(f"{material_id}已放入加热台{station_id}")
-            self.logger.info(f"[{material_id}] 已放入加热台{station_id} (用时{self.ARM_OPERATION_TIME}s)")
-
-            # 释放机械臂
-            self._release_arm()
-
-            with self._tasks_lock:
-                self._active_tasks[material_id]["status"] = "placed_on_station"
-
-            return {
-                "success": True,
-                "station_id": station_id,
-                "material_id": material_id,
-                "material_number": material_number,
-                "message": f"{material_id}已成功移动到加热台{station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        except Exception as e:
-            self.logger.error(f"[{material_id}] 移动失败: {str(e)}")
-            if self._arm_lock.locked():
-                self._release_arm()
-            return {
-                "success": False,
-                "station_id": -1,
-                "material_id": material_id,
-                "material_number": material_number,
-                "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-    @always_free
-    def start_heating(
-        self,
-        sample_uuids: SampleUUIDsType,
-        station_id: int,
-        material_number: int,
-    ) -> StartHeatingResult:
-        """
-        启动指定加热台的加热程序
-
-        Args:
-            station_id: 加热台ID (1-3)，从 move_to_heating_station 的 handle 传入
-            material_number: 物料编号，从 move_to_heating_station 的 handle 传入
-
-        Returns:
-            StartHeatingResult: 包含 station_id, material_number 等用于传递给下一个节点
-        """
-        self.logger.info(f"[加热台{station_id}] 开始加热")
-
-        if station_id not in self._heating_stations:
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "material_number": material_number,
-                "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        with self._stations_lock:
-            station = self._heating_stations[station_id]
-
-            if station.current_material is None:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": "",
-                    "material_number": material_number,
-                    "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            if station.state == HeatingStationState.HEATING:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": station.current_material,
-                    "material_number": material_number,
-                    "message": f"加热台{station_id}已经在加热中",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            material_id = station.current_material
-
-            # 开始加热
-            station.state = HeatingStationState.HEATING
-            station.heating_start_time = time.time()
-            station.heating_progress = 0.0
-
-        with self._tasks_lock:
-            if material_id in self._active_tasks:
-                self._active_tasks[material_id]["status"] = "heating"
-
-        self._update_data_status(f"加热台{station_id}开始加热{material_id}")
-
-        # 打印当前所有正在加热的台位
-        with self._stations_lock:
-            heating_list = [
-                f"加热台{sid}:{s.current_material}"
-                for sid, s in self._heating_stations.items()
-                if s.state == HeatingStationState.HEATING and s.current_material
-            ]
-        self.logger.info(f"[并行加热] 当前同时加热中: {', '.join(heating_list)}")
-
-        # 模拟加热过程
-        start_time = time.time()
-        last_countdown_log = start_time
-        while True:
-            elapsed = time.time() - start_time
-            remaining = max(0.0, self.HEATING_TIME - elapsed)
-            progress = min(100.0, (elapsed / self.HEATING_TIME) * 100)
-
-            with self._stations_lock:
-                self._heating_stations[station_id].heating_progress = progress
-
-            self._update_data_status(f"加热台{station_id}加热中: {progress:.1f}%")
-
-            # 每5秒打印一次倒计时
-            if time.time() - last_countdown_log >= 5.0:
-                self.logger.info(f"[加热台{station_id}] {material_id} 剩余 {remaining:.1f}s")
-                last_countdown_log = time.time()
-
-            if elapsed >= self.HEATING_TIME:
-                break
-
-            time.sleep(1.0)
-
-        # 加热完成
-        with self._stations_lock:
-            self._heating_stations[station_id].state = HeatingStationState.COMPLETED
-            self._heating_stations[station_id].heating_progress = 100.0
-
-        with self._tasks_lock:
-            if material_id in self._active_tasks:
-                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)")
-
-        return {
-            "success": True,
-            "station_id": station_id,
-            "material_id": material_id,
-            "material_number": material_number,
-            "message": f"加热台{station_id}加热完成",
-            "unilabos_samples": [
-                LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                sample_uuid, content in sample_uuids.items()]
-        }
-
-    def move_to_output(
-        self,
-        sample_uuids: SampleUUIDsType,
-        station_id: int,
-        material_number: int,
-    ) -> MoveToOutputResult:
-        """
-        将物料从加热台移动到输出位置Cn
-
-        Args:
-            station_id: 加热台ID (1-3)，从 start_heating 的 handle 传入
-            material_number: 物料编号，从 start_heating 的 handle 传入，用于确定输出位置 Cn
-
-        Returns:
-            MoveToOutputResult: 包含执行结果
-        """
-        output_number = material_number  # 物料编号决定输出位置
-
-        if station_id not in self._heating_stations:
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "output_position": f"C{output_number}",
-                "message": f"无效的加热台ID: {station_id}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        with self._stations_lock:
-            station = self._heating_stations[station_id]
-            material_id = station.current_material
-
-            if material_id is None:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": "",
-                    "output_position": f"C{output_number}",
-                    "message": f"加热台{station_id}上没有物料",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-            if station.state != HeatingStationState.COMPLETED:
-                return {
-                    "success": False,
-                    "station_id": station_id,
-                    "material_id": material_id,
-                    "output_position": f"C{output_number}",
-                    "message": f"加热台{station_id}尚未完成加热 (当前状态: {station.state.value})",
-                    "unilabos_samples": [
-                        LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                        sample_uuid, content in sample_uuids.items()]
-                }
-
-        output_position = f"C{output_number}"
-        task_desc = f"从加热台{station_id}移动{material_id}到{output_position}"
-        self.logger.info(f"[任务] {task_desc}")
-
-        try:
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "waiting_for_arm_output"
-
-            # 获取机械臂
-            self._acquire_arm(task_desc)
-
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "arm_moving_to_output"
-
-            # 模拟机械臂操作 (3秒)
-            self.logger.info(f"[{material_id}] 机械臂正在从加热台{station_id}取出并移动到{output_position}...")
-            time.sleep(self.ARM_OPERATION_TIME)
-
-            # 清空加热台
-            with self._stations_lock:
-                self._heating_stations[station_id].state = HeatingStationState.IDLE
-                self._heating_stations[station_id].current_material = None
-                self._heating_stations[station_id].material_number = None
-                self._heating_stations[station_id].heating_progress = 0.0
-                self._heating_stations[station_id].heating_start_time = None
-
-            # 释放机械臂
-            self._release_arm()
-
-            # 任务完成
-            with self._tasks_lock:
-                if material_id in self._active_tasks:
-                    self._active_tasks[material_id]["status"] = "completed"
-                    self._active_tasks[material_id]["end_time"] = time.time()
-
-            self._update_data_status(f"{material_id}已移动到{output_position}")
-            self.logger.info(f"[{material_id}] 已成功移动到{output_position} (用时{self.ARM_OPERATION_TIME}s)")
-
-            return {
-                "success": True,
-                "station_id": station_id,
-                "material_id": material_id,
-                "output_position": output_position,
-                "message": f"{material_id}已成功移动到{output_position}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-        except Exception as e:
-            self.logger.error(f"移动到输出位置失败: {str(e)}")
-            if self._arm_lock.locked():
-                self._release_arm()
-            return {
-                "success": False,
-                "station_id": station_id,
-                "material_id": "",
-                "output_position": output_position,
-                "message": f"移动失败: {str(e)}",
-                "unilabos_samples": [
-                    LabSample(sample_uuid=sample_uuid, oss_path="", extra={"material_uuid": content} if isinstance(content, str) else content.serialize()) for
-                    sample_uuid, content in sample_uuids.items()]
-            }
-
-    # ============ 状态属性 ============
-
-    @property
-    def status(self) -> str:
-        return self.data.get("status", "Unknown")
-
-    @property
-    def arm_state(self) -> str:
-        return self._arm_state.value
-
-    @property
-    def arm_current_task(self) -> str:
-        return self._arm_current_task or ""
-
-    @property
-    def heating_station_1_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_1_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_1_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(1)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def heating_station_2_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_2_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_2_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(2)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def heating_station_3_state(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.state.value if station else "unknown"
-
-    @property
-    def heating_station_3_material(self) -> str:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.current_material or "" if station else ""
-
-    @property
-    def heating_station_3_progress(self) -> float:
-        with self._stations_lock:
-            station = self._heating_stations.get(3)
-            return station.heating_progress if station else 0.0
-
-    @property
-    def active_tasks_count(self) -> int:
-        with self._tasks_lock:
-            return len(self._active_tasks)
-
-    @property
-    def message(self) -> str:
-        return self.data.get("message", "")

unilabos/devices/workstation/README.md

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

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

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

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

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

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

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

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

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

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

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

unilabos/devices/workstation/bioyond_studio/config.py

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

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

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

unilabos/devices/workstation/bioyond_studio/dispensing_station.py

@@ -4,8 +4,7 @@ import time
 from typing import Optional, Dict, Any, List
 from typing_extensions import TypedDict
 import requests
-import pint
-
+from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
 
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondException
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
@@ -26,89 +25,13 @@ class ComputeExperimentDesignReturn(TypedDict):
 class BioyondDispensingStation(BioyondWorkstation):
     def __init__(
         self,
-        config: dict = None,
-        deck=None,
-        protocol_type=None,
+        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)
-
+        ):
+        super().__init__(config, deck, *args, **kwargs)
         # self.config = config
         # self.api_key = config["api_key"]
         # self.host = config["api_host"]
@@ -120,41 +43,6 @@ 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调用
 
@@ -166,7 +54,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             dict: 服务端响应，失败时返回 {code:0,message,...}
         """
         request_data = {
-            "apiKey": self.bioyond_config["api_key"],
+            "apiKey": API_CONFIG["api_key"],
             "requestTime": self.hardware_interface.get_current_time_iso8601(),
             "data": data
         }
@@ -197,7 +85,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             dict: 服务端响应，失败时返回 {code:0,message,...}
         """
         request_data = {
-            "apiKey": self.bioyond_config["api_key"],
+            "apiKey": API_CONFIG["api_key"],
             "requestTime": self.hardware_interface.get_current_time_iso8601(),
             "data": data
         }
@@ -230,22 +118,20 @@ 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}")
-
-            # 2. 调用内部计算方法
-            res = self._generate_experiment_design(
-                ratio=ratio,
-                wt_percent=wp,
-                m_tot=mt,
-                titration_percent=tp
-            )
-
-            # 3. 构造返回结果
+            res = mod.generate_experiment_design(ratio=ratio, wt_percent=wp, m_tot=mt, titration_percent=tp)
             out = {
                 "solutions": res.get("solutions", []),
                 "titration": res.get("titration", {}),
@@ -254,248 +140,11 @@ 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,
@@ -1312,108 +961,6 @@ 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,
@@ -1455,12 +1002,7 @@ class BioyondDispensingStation(BioyondWorkstation):
 
             # 验证batch_create_result参数
             if not batch_create_result or batch_create_result == "":
-                raise BioyondException(
-                    "batch_create_result参数为空，请确保:\n"
-                    "1. batch_create节点与wait节点之间正确连接了handle\n"
-                    "2. batch_create节点成功执行并返回了结果\n"
-                    "3. 检查上游batch_create任务是否成功创建了订单"
-                )
+                raise BioyondException("batch_create_result参数为空，请确保从batch_create节点正确连接handle")
 
             # 解析batch_create_result JSON对象
             try:
@@ -1489,17 +1031,7 @@ class BioyondDispensingStation(BioyondWorkstation):
 
             # 验证提取的数据
             if not 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任务的执行结果"
-                )
+                raise BioyondException("batch_create_result中未找到order_codes字段或为空")
             if not order_ids:
                 raise BioyondException("batch_create_result中未找到order_ids字段或为空")
 
@@ -1582,8 +1114,6 @@ class BioyondDispensingStation(BioyondWorkstation):
                                 self.hardware_interface._logger.info(
                                     f"成功获取任务 {order_code} 的实验报告"
                                 )
-                                # 简化报告，去除冗余信息
-                                report = self._simplify_report(report)
 
                             reports.append({
                                 "order_code": order_code,
@@ -1758,7 +1288,7 @@ class BioyondDispensingStation(BioyondWorkstation):
                 f"开始执行批量物料转移: {len(transfer_groups)}组任务 -> {target_device_id}"
             )
 
-            warehouse_mapping = self.bioyond_config.get("warehouse_mapping", {})
+            from .config import WAREHOUSE_MAPPING
             results = []
             successful_count = 0
             failed_count = 0

unilabos/devices/workstation/bioyond_studio/station.py

@@ -6,7 +6,6 @@ Bioyond Workstation Implementation
 """
 import time
 import traceback
-import threading
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -24,94 +23,12 @@ 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资源同步器
 
@@ -257,8 +174,9 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             else:
                 logger.info(f"[同步→Bioyond] ➕ 物料不存在于 Bioyond，将创建新物料并入库")
 
-            # 第1步：从配置中获取仓库配置
-            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
+            # 第1步：获取仓库配置
+            from .config import WAREHOUSE_MAPPING
+            warehouse_mapping = WAREHOUSE_MAPPING
 
             # 确定目标仓库名称
             parent_name = None
@@ -320,20 +238,14 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             # 第2步：转换为 Bioyond 格式
             logger.info(f"[同步→Bioyond] 🔄 转换物料为 Bioyond 格式...")
 
-            # 从配置中获取物料默认参数
-            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
+            # 导入物料默认参数配置
+            from .config import MATERIAL_DEFAULT_PARAMETERS
 
             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=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
             )[0]
 
             logger.info(f"[同步→Bioyond] 🔧 准备覆盖locations字段，目标仓库: {parent_name}, 库位: {update_site}, UUID: {target_location_uuid[:8]}...")
@@ -556,20 +468,13 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 return material_bioyond_id
 
             # 转换为 Bioyond 格式
-            # 从配置中获取物料默认参数
-            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
+            from .config import MATERIAL_DEFAULT_PARAMETERS
 
             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=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
             )[0]
 
             # ⚠️ 关键：创建物料时不设置 locations，让 Bioyond 系统暂不分配库位
@@ -623,7 +528,8 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             logger.info(f"[物料入库] 目标库位: {update_site}")
 
             # 获取仓库配置和目标库位 UUID
-            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
+            from .config import WAREHOUSE_MAPPING
+            warehouse_mapping = WAREHOUSE_MAPPING
 
             parent_name = None
             target_location_uuid = None
@@ -678,44 +584,6 @@ 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,
@@ -737,28 +605,10 @@ class BioyondWorkstation(WorkstationBase):
             raise ValueError("Deck 配置不能为空，请在配置文件中添加正确的 deck 配置")
 
         # 初始化 warehouses 属性
-        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.deck.warehouses = {}
+        for resource in self.deck.children:
+            if isinstance(resource, WareHouse):
+                self.deck.warehouses[resource.name] = resource
 
         # 创建通信模块
         self._create_communication_module(bioyond_config)
@@ -777,22 +627,18 @@ class BioyondWorkstation(WorkstationBase):
             self._set_workflow_mappings(bioyond_config["workflow_mappings"])
 
         # 准备 HTTP 报送接收服务配置（延迟到 post_init 启动）
-        # 从 bioyond_config 中的 http_service_config 获取
-        http_service_cfg = bioyond_config.get("http_service_config", {})
+        # 从 bioyond_config 中获取，如果没有则使用 HTTP_SERVICE_CONFIG 的默认值
         self._http_service_config = {
-            "host": http_service_cfg.get("http_service_host", "127.0.0.1"),
-            "port": http_service_cfg.get("http_service_port", 8080)
+            "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"])
         }
-        self.http_service = None  # 将在 post_init 启动
-        self.connection_monitor = None # 将在 post_init 启动
+        self.http_service = 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()
@@ -802,19 +648,8 @@ 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 已可用）
-        # ⚠️ 检查子类是否已经自己管理 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'):
+        if hasattr(self, '_http_service_config'):
             try:
                 self.http_service = WorkstationHTTPService(
                     workstation_instance=self,
@@ -853,14 +688,19 @@ class BioyondWorkstation(WorkstationBase):
 
     def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None:
         """创建Bioyond通信模块"""
-        # 直接使用传入的配置，不再使用默认值
-        # 所有配置必须从 JSON 文件中提供
+        # 创建默认配置
+        default_config = {
+            **API_CONFIG,
+            "workflow_mappings": WORKFLOW_MAPPINGS,
+            "material_type_mappings": MATERIAL_TYPE_MAPPINGS,
+            "warehouse_mapping": WAREHOUSE_MAPPING
+        }
+
+        # 如果传入了 config，合并配置（config 中的值会覆盖默认值）
         if config:
-            self.bioyond_config = config
+            self.bioyond_config = {**default_config, **config}
         else:
-            # 如果没有配置，使用空字典（会导致后续错误，但这是预期的）
-            self.bioyond_config = {}
-            print("警告: 未提供 bioyond_config，请确保在 JSON 配置文件中提供完整配置")
+            self.bioyond_config = default_config
 
         self.hardware_interface = BioyondV1RPC(self.bioyond_config)
 
@@ -1174,15 +1014,7 @@ class BioyondWorkstation(WorkstationBase):
 
         workflow_id = self._get_workflow(actual_workflow_name)
         if 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
-
+            self.workflow_sequence.append(workflow_id)
             print(f"添加工作流到执行顺序: {actual_workflow_name} -> {workflow_id}")
             return True
         return False
@@ -1383,22 +1215,6 @@ 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'),
@@ -1433,17 +1249,6 @@ 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'),
@@ -1483,32 +1288,6 @@ 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

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

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

@@ -1,645 +0,0 @@
-"""
-纽扣电池组装工作站物料类定义
-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

@@ -1,133 +0,0 @@
-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-电解液瓶盖在籍异常

unilabos/devices/workstation/workstation_http_service.py

@@ -459,12 +459,12 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
             # 验证必需字段
             if 'brand' in request_data:
                 if request_data['brand'] == "bioyond":  # 奔曜
-                    material_data = request_data["text"]
-                    logger.info(f"收到奔曜物料变更报送: {material_data}")
+                    error_msg = request_data["text"]
+                    logger.info(f"收到奔曜错误处理报送: {error_msg}")
                     return HttpResponse(
                         success=True,
-                        message=f"物料变更报送已收到: {material_data}",
-                        acknowledgment_id=f"MATERIAL_{int(time.time() * 1000)}_{material_data.get('id', 'unknown')}",
+                        message=f"错误处理报送已收到: {error_msg}",
+                        acknowledgment_id=f"ERROR_{int(time.time() * 1000)}_{error_msg.get('action_id', 'unknown')}",
                         data=None
                     )
             else:

unilabos/registry/device_comms/communication_devices.yaml

@@ -96,13 +96,10 @@ serial:
           type: string
         port:
           type: string
-        registry_name:
-          type: string
         resource_tracker:
           type: object
       required:
       - device_id
-      - registry_name
       - port
       type: object
     data: