扣电驱动中增加多个组装参数，更新驱动与注册表 (#120)

扣电驱动中增加多个组装参数，elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200，更新驱动与注册表

.conda/recipe.yaml

@@ -0,0 +1,89 @@
+package:
+  name: unilabos
+  version: 0.10.6
+
+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
+  run:
+  - conda-forge::python ==3.11.11
+  - compilers
+  - cmake
+  - zstd
+  - 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/dptech-corp/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

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

@@ -0,0 +1,131 @@
+name: Multi-Platform Conda Build
+
+on:
+  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: 'osx-arm64'
+      upload_to_anaconda:
+        description: '是否上传到Anaconda.org'
+        required: false
+        default: false
+        type: boolean
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: linux-64
+            env_file: unilabos-linux-64.yaml
+          - os: macos-13 # Intel
+            platform: osx-64
+            env_file: unilabos-osx-64.yaml
+          - os: macos-latest # ARM64
+            platform: osx-arm64
+            env_file: unilabos-osx-arm64.yaml
+          - os: windows-latest
+            platform: win-64
+            env_file: unilabos-win64.yaml
+
+    runs-on: ${{ matrix.os }}
+
+    defaults:
+      run:
+        shell: bash -l {0}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check if platform should be built
+        id: should_build
+        run: |
+          if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          else
+            echo "should_build=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Setup Miniconda
+        if: steps.should_build.outputs.should_build == 'true'
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniconda-version: 'latest'
+          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
+
+      - name: Install rattler-build and anaconda-client
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          conda install -c conda-forge rattler-build anaconda-client
+
+      - name: Show environment info
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          conda info
+          conda list | grep -E "(rattler-build|anaconda-client)"
+          echo "Platform: ${{ matrix.platform }}"
+          echo "OS: ${{ matrix.os }}"
+
+      - name: Build conda package
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          if [[ "${{ matrix.platform }}" == "osx-arm64" ]]; then
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          else
+            rattler-build build -r ./recipes/msgs/recipe.yaml -c robostack -c robostack-staging -c conda-forge
+          fi
+
+      - name: List built packages
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          echo "Built packages in output directory:"
+          find ./output -name "*.conda" | head -10
+          ls -la ./output/${{ matrix.platform }}/ || echo "${{ matrix.platform }} directory not found"
+          ls -la ./output/noarch/ || echo "noarch directory not found"
+          echo "Output directory structure:"
+          find ./output -type f -name "*.conda"
+
+      - name: Prepare artifacts for upload
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          mkdir -p conda-packages-temp
+          find ./output -name "*.conda" -exec cp {} conda-packages-temp/ \;
+          echo "Copied files to temp directory:"
+          ls -la conda-packages-temp/
+
+      - name: Upload conda package artifacts
+        if: steps.should_build.outputs.should_build == 'true'
+        uses: actions/upload-artifact@v4
+        with:
+          name: conda-package-${{ matrix.platform }}
+          path: conda-packages-temp
+          if-no-files-found: warn
+          retention-days: 30
+
+      - name: Upload to Anaconda.org (unilab organization)
+        if: steps.should_build.outputs.should_build == 'true' && github.event.inputs.upload_to_anaconda == 'true'
+        run: |
+          for package in $(find ./output -name "*.conda"); do
+            echo "Uploading $package to unilab organization..."
+            anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload --user uni-lab --force "$package"
+          done

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

@@ -0,0 +1,124 @@
+name: UniLabOS Conda Build
+
+on:
+  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'
+      upload_to_anaconda:
+        description: '是否上传到Anaconda.org'
+        required: false
+        default: false
+        type: boolean
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: linux-64
+          - os: macos-13 # Intel
+            platform: osx-64
+          - os: macos-latest # ARM64
+            platform: osx-arm64
+          - os: windows-latest
+            platform: win-64
+
+    runs-on: ${{ matrix.os }}
+
+    defaults:
+      run:
+        shell: bash -l {0}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check if platform should be built
+        id: should_build
+        run: |
+          if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          else
+            echo "should_build=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Setup Miniconda
+        if: steps.should_build.outputs.should_build == 'true'
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          miniconda-version: 'latest'
+          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
+
+      - name: Install rattler-build and anaconda-client
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          conda install -c conda-forge rattler-build anaconda-client
+
+      - name: Show environment info
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          conda info
+          conda list | grep -E "(rattler-build|anaconda-client)"
+          echo "Platform: ${{ matrix.platform }}"
+          echo "OS: ${{ matrix.os }}"
+          echo "Building UniLabOS package"
+
+      - name: Build conda package
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          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'
+        run: |
+          echo "Built packages in output directory:"
+          find ./output -name "*.conda" | head -10
+          ls -la ./output/${{ matrix.platform }}/ || echo "${{ matrix.platform }} directory not found"
+          ls -la ./output/noarch/ || echo "noarch directory not found"
+          echo "Output directory structure:"
+          find ./output -type f -name "*.conda"
+
+      - name: Prepare artifacts for upload
+        if: steps.should_build.outputs.should_build == 'true'
+        run: |
+          mkdir -p conda-packages-temp
+          find ./output -name "*.conda" -exec cp {} conda-packages-temp/ \;
+          echo "Copied files to temp directory:"
+          ls -la conda-packages-temp/
+
+      - name: Upload conda package artifacts
+        if: steps.should_build.outputs.should_build == 'true'
+        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

@@ -1,3 +1,7 @@
+configs/
+temp/
+output/
+unilabos_data/
 ## Python
 
 # Byte-compiled / optimized / DLL files
@@ -234,3 +238,13 @@ CATKIN_IGNORE
 
 *.graphml
 unilabos/device_mesh/view_robot.rviz
+
+
+# Certs
+**/.certs
+local_test2.py
+ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
+*.bz2
+test_config.py
+
+

MANIFEST.in

@@ -1,5 +1,5 @@
 recursive-include unilabos/registry *.yaml
-recursive-include unilabos/app/web *.html
-recursive-include unilabos/app/web *.css
+recursive-include unilabos/app/web/static *
+recursive-include unilabos/app/web/templates *
 recursive-include unilabos/device_mesh/devices *
 recursive-include unilabos/device_mesh/resources *

README.md

@@ -5,6 +5,7 @@
 # Uni-Lab-OS
 
 <!-- Language switcher -->
+
 **English** | [中文](README_zh.md)
 
 [![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
@@ -34,30 +35,14 @@ Detailed documentation can be found at:
 
 ## Quick Start
 
-1. Configure Conda Environment
-
 Uni-Lab-OS recommends using `mamba` for environment management. Choose the appropriate environment file for your operating system:
 
 ```bash
 # Create new environment
-mamba env create -f unilabos-[YOUR_OS].yaml
-mamba activate unilab
-
-# Or update existing environment
-# Where `[YOUR_OS]` can be `win64`, `linux-64`, `osx-64`, or `osx-arm64`.
-conda env update --file unilabos-[YOUR_OS].yml -n environment_name
-
-# Currently, you need to install the `unilabos_msgs` package
-# You can download the system-specific package from the Release page
-conda install ros-humble-unilabos-msgs-0.9.5-xxxxx.tar.bz2
-
-# Install PyLabRobot and other prerequisites
-git clone https://github.com/PyLabRobot/pylabrobot plr_repo
-cd plr_repo
-pip install .[opentrons]
+mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-2. Install Uni-Lab-OS:
+## Install Dev Uni-Lab-OS
 
 ```bash
 # Clone the repository

README_zh.md

@@ -5,6 +5,7 @@
 # Uni-Lab-OS
 
 <!-- Language switcher -->
+
 [English](README.md) | **中文**
 
 [![GitHub Stars](https://img.shields.io/github/stars/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/stargazers)
@@ -12,7 +13,7 @@
 [![GitHub Issues](https://img.shields.io/github/issues/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/issues)
 [![GitHub License](https://img.shields.io/github/license/dptech-corp/Uni-Lab-OS.svg)](https://github.com/dptech-corp/Uni-Lab-OS/blob/main/LICENSE)
 
-Uni-Lab-OS是一个用于实验室自动化的综合平台，旨在连接和控制各种实验设备，实现实验流程的自动化和标准化。
+Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控制各种实验设备，实现实验流程的自动化和标准化。
 
 ## 🏆 比赛
 
@@ -34,30 +35,16 @@ Uni-Lab-OS是一个用于实验室自动化的综合平台，旨在连接和控
 
 ## 快速开始
 
-1. 配置Conda环境
+1. 配置 Conda 环境
 
 Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适当的环境文件:
 
 ```bash
 # 创建新环境
-mamba env create -f unilabos-[YOUR_OS].yaml
-mamba activate unilab
-
-# 或更新现有环境
-# 其中 `[YOUR_OS]` 可以是 `win64`, `linux-64`, `osx-64`, 或 `osx-arm64`。
-conda env update --file unilabos-[YOUR_OS].yml -n 环境名
-
-# 现阶段，需要安装 `unilabos_msgs` 包
-# 可以前往 Release 页面下载系统对应的包进行安装
-conda install ros-humble-unilabos-msgs-0.9.5-xxxxx.tar.bz2
-
-# 安装PyLabRobot等前置
-git clone https://github.com/PyLabRobot/pylabrobot plr_repo
-cd plr_repo
-pip install .[opentrons]
+mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-2. 安装 Uni-Lab-OS:
+2. 安装开发版 Uni-Lab-OS:
 
 ```bash
 # 克隆仓库

docs/boot_examples/liquid_handler.md

@@ -13,18 +13,16 @@
 ```json
 {
   "nodes": [
-        {
-            "id": "PLR_STATION",
-            "name": "PLR_LH_TEST",
-            "parent": null,
-            "type": "device",
-            "class": "liquid_handler",
-            "config": {},
-            "data": {},
-            "children": [
-                "deck"
-            ]
-        },
+    {
+      "id": "PLR_STATION",
+      "name": "PLR_LH_TEST",
+      "parent": null,
+      "type": "device",
+      "class": "liquid_handler",
+      "config": {},
+      "data": {},
+      "children": ["deck"]
+    },
     {
       "id": "deck",
       "name": "deck",
@@ -32,12 +30,12 @@
       "class": null,
       "parent": "PLR_STATION",
       "children": [
-                "trash",
-                "trash_core96",
-                "teaching_carrier",
-                "tip_rack",
-                "plate"
-            ]
+        "trash",
+        "trash_core96",
+        "teaching_carrier",
+        "tip_rack",
+        "plate"
+      ]
     }
   ],
   "links": []
@@ -45,6 +43,7 @@
 ```
 
 配置文件定义了移液站的组成部分，主要包括：
+
 - 移液站本体（LiquidHandler）- 设备类型
 - 移液站携带物料实例（deck）- 物料类型
 
@@ -55,7 +54,7 @@
 使用以下命令启动移液站设备：
 
 ```bash
-unilab -g test/experiments/plr_test.json --app_bridges ""
+unilab -g test/experiments/plr_test.json --ak [通过网页获取的ak值] --sk [通过网页获取的sk值]
 ```
 
 ### 2. 执行枪头插入操作
@@ -66,7 +65,7 @@ unilab -g test/experiments/plr_test.json --app_bridges ""
 ros2 action send_goal /devices/PLR_STATION/pick_up_tips unilabos_msgs/action/_liquid_handler_pick_up_tips/LiquidHandlerPickUpTips "{ tip_spots: [ { id: 'tip_rack_tipspot_0_0', name: 'tip_rack_tipspot_0_0', sample_id: null, children: [], parent: 'tip_rack', type: 'device', config: { position: { x: 7.2, y: 68.3, z: -83.5 }, size_x: 9.0, size_y: 9.0, size_z: 0, rotation: { x: 0, y: 0, z: 0, type: 'Rotation' }, category: 'tip_spot', model: null, type: 'TipSpot', prototype_tip: { type: 'HamiltonTip', total_tip_length: 95.1, has_filter: true, maximal_volume: 1065, pickup_method: 'OUT_OF_RACK', tip_size: 'HIGH_VOLUME' } }, data: { tip: { type: 'HamiltonTip', total_tip_length: 95.1, has_filter: true, maximal_volume: 1065, pickup_method: 'OUT_OF_RACK', tip_size: 'HIGH_VOLUME' }, tip_state: { liquids: [], pending_liquids: [], liquid_history: [] }, pending_tip: { type: 'HamiltonTip', total_tip_length: 95.1, has_filter: true, maximal_volume: 1065, pickup_method: 'OUT_OF_RACK', tip_size: 'HIGH_VOLUME' } } } ], use_channels: [ 0 ], offsets: [ { x: 0.0, y: 0.0, z: 0.0 } ] }"
 ```
 
-此命令会通过ros通信触发移液站执行枪头插入操作，得到如下的PyLabRobot的输出日志。
+此命令会通过 ros 通信触发移液站执行枪头插入操作，得到如下的 PyLabRobot 的输出日志。
 
 ```log
 Picking up tips:
@@ -74,27 +73,42 @@ pip#  resource             offset           tip type     max volume (µL)  fitti
   p0: tip_rack_tipspot_0_0 0.0,0.0,0.0      HamiltonTip  1065             8                    95.1             Yes
 ```
 
+也可以登陆网页，给`tip_spots`选择`tip_rack_tipspot_0_0`，`use_channels`为`0`，`offsets`均填写`0`，同样可观察到上面的日志
+
 ## 常见问题
 
-1. **重复插入枪头不成功**：操作编排应该符合实际操作顺序，可自行通过PyLabRobot进行测试
+1. **重复插入枪头不成功**：操作编排应该符合实际操作顺序，可自行通过 PyLabRobot 进行测试
 
 ## 移液站支持的操作
 
 移液站支持多种操作，以下是当前系统支持的操作列表：
 
-1. **LiquidHandlerAspirate** - 吸液操作
-2. **LiquidHandlerDispense** - 排液操作
-3. **LiquidHandlerDiscardTips** - 丢弃枪头
-4. **LiquidHandlerDropTips** - 卸下枪头
-5. **LiquidHandlerDropTips96** - 卸下96通道枪头
-6. **LiquidHandlerMoveLid** - 移动盖子
-7. **LiquidHandlerMovePlate** - 移动板子
-8. **LiquidHandlerMoveResource** - 移动资源
-9. **LiquidHandlerPickUpTips** - 插入枪头
-10. **LiquidHandlerPickUpTips96** - 插入96通道枪头
-11. **LiquidHandlerReturnTips** - 归还枪头
-12. **LiquidHandlerReturnTips96** - 归还96通道枪头
-13. **LiquidHandlerStamp** - 打印标记
-14. **LiquidHandlerTransfer** - 液体转移
+1. **LiquidHandlerProtocolCreation** - 协议创建
+2. **LiquidHandlerAspirate** - 吸液操作
+3. **LiquidHandlerDispense** - 排液操作
+4. **LiquidHandlerDiscardTips** - 丢弃枪头
+5. **LiquidHandlerDropTips** - 卸下枪头
+6. **LiquidHandlerDropTips96** - 卸下 96 通道枪头
+7. **LiquidHandlerMoveLid** - 移动盖子
+8. **LiquidHandlerMovePlate** - 移动板子
+9. **LiquidHandlerMoveResource** - 移动资源
+10. **LiquidHandlerPickUpTips** - 插入枪头
+11. **LiquidHandlerPickUpTips96** - 插入 96 通道枪头
+12. **LiquidHandlerReturnTips** - 归还枪头
+13. **LiquidHandlerReturnTips96** - 归还 96 通道枪头
+14. **LiquidHandlerSetLiquid** - 设置液体
+15. **LiquidHandlerSetTipRack** - 设置枪头架
+16. **LiquidHandlerStamp** - 打印标记
+17. **LiquidHandlerTransfer** - 液体转移
+18. **LiquidHandlerSetGroup** - 设置分组
+19. **LiquidHandlerTransferBiomek** - Biomek 液体转移
+20. **LiquidHandlerIncubateBiomek** - Biomek 孵育
+21. **LiquidHandlerMoveBiomek** - Biomek 移动
+22. **LiquidHandlerOscillateBiomek** - Biomek 振荡
+23. **LiquidHandlerTransferGroup** - 分组转移
+24. **LiquidHandlerAdd** - 添加操作
+25. **LiquidHandlerMix** - 混合操作
+26. **LiquidHandlerMoveTo** - 移动到指定位置
+27. **LiquidHandlerRemove** - 移除操作
 
-这些操作可通过ROS2 Action接口进行调用，以实现复杂的移液流程。
+这些操作可通过 ROS2 Action 接口进行调用，以实现复杂的移液流程。

docs/concepts/02-topology-and-chemputer-compile.md

@@ -19,7 +19,7 @@ Uni-Lab 的组态图当前支持 node-link json 和 graphml 格式，其中包
 对用户来说，“直接操作设备执行单个指令”不是个真实需求，真正的需求是**“执行对实验有意义的单个完整动作”——加入某种液体多少量；萃取分液；洗涤仪器等等。就像实验步骤文字书写的那样。**
 
 而这些对实验有意义的单个完整动作，**一般需要多个设备的协同**，还依赖于他们的**物理连接关系（管道相连；机械臂可转运）**。
-于是 Uni-Lab 实现了抽象的“工作站”，即注册表中的 `workstation` 设备（`ProtocolNode`类）来处理编译、规划操作。以泵骨架组成的自动有机实验室为例，设备管道连接关系如下：
+于是 Uni-Lab 实现了抽象的“工作站”，即注册表中的 `workstation` 设备（`WorkstationNode`类）来处理编译、规划操作。以泵骨架组成的自动有机实验室为例，设备管道连接关系如下：
 
 ![topology](image/02-topology-and-chemputer-compile/topology.png)
 

docs/developer_guide/action_includes.md

@@ -1,26 +1,64 @@
 ## 简单单变量动作函数
 
-
 ### `SendCmd`
 
 ```{literalinclude} ../../unilabos_msgs/action/SendCmd.action
 :language: yaml
 ```
 
-----
+---
+
+### `StrSingleInput`
+
+```{literalinclude} ../../unilabos_msgs/action/StrSingleInput.action
+:language: yaml
+```
+
+---
+
+### `IntSingleInput`
+
+```{literalinclude} ../../unilabos_msgs/action/IntSingleInput.action
+:language: yaml
+```
+
+---
+
+### `FloatSingleInput`
+
+```{literalinclude} ../../unilabos_msgs/action/FloatSingleInput.action
+:language: yaml
+```
+
+---
+
+### `Point3DSeparateInput`
+
+```{literalinclude} ../../unilabos_msgs/action/Point3DSeparateInput.action
+:language: yaml
+```
+
+---
+
+### `Wait`
+
+```{literalinclude} ../../unilabos_msgs/action/Wait.action
+:language: yaml
+```
+
+---
+
 ## 常量有机化学操作
 
 Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab.io/chemputer/xdl/standard/full_steps_specification.html#)，包含有机合成实验中常见的操作，如加热、搅拌、冷却等。
 
-
-
 ### `Clean`
 
 ```{literalinclude} ../../unilabos_msgs/action/Clean.action
 :language: yaml
 ```
 
-----
+---
 
 ### `EvacuateAndRefill`
 
@@ -28,7 +66,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `Evaporate`
 
@@ -36,7 +74,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `HeatChill`
 
@@ -44,7 +82,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `HeatChillStart`
 
@@ -52,7 +90,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `HeatChillStop`
 
@@ -60,7 +98,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `PumpTransfer`
 
@@ -68,7 +106,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `Separate`
 
@@ -76,7 +114,7 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
 
 ### `Stir`
 
@@ -84,20 +122,179 @@ Uni-Lab 常量有机化学指令集多数来自 [XDL](https://croningroup.gitlab
 :language: yaml
 ```
 
-----
+---
+
+### `Add`
+
+```{literalinclude} ../../unilabos_msgs/action/Add.action
+:language: yaml
+```
+
+---
+
+### `AddSolid`
+
+```{literalinclude} ../../unilabos_msgs/action/AddSolid.action
+:language: yaml
+```
+
+---
+
+### `AdjustPH`
+
+```{literalinclude} ../../unilabos_msgs/action/AdjustPH.action
+:language: yaml
+```
+
+---
+
+### `Centrifuge`
+
+```{literalinclude} ../../unilabos_msgs/action/Centrifuge.action
+:language: yaml
+```
+
+---
+
+### `CleanVessel`
+
+```{literalinclude} ../../unilabos_msgs/action/CleanVessel.action
+:language: yaml
+```
+
+---
+
+### `Crystallize`
+
+```{literalinclude} ../../unilabos_msgs/action/Crystallize.action
+:language: yaml
+```
+
+---
+
+### `Dissolve`
+
+```{literalinclude} ../../unilabos_msgs/action/Dissolve.action
+:language: yaml
+```
+
+---
+
+### `Dry`
+
+```{literalinclude} ../../unilabos_msgs/action/Dry.action
+:language: yaml
+```
+
+---
+
+### `Filter`
+
+```{literalinclude} ../../unilabos_msgs/action/Filter.action
+:language: yaml
+```
+
+---
+
+### `FilterThrough`
+
+```{literalinclude} ../../unilabos_msgs/action/FilterThrough.action
+:language: yaml
+```
+
+---
+
+### `Hydrogenate`
+
+```{literalinclude} ../../unilabos_msgs/action/Hydrogenate.action
+:language: yaml
+```
+
+---
+
+### `Purge`
+
+```{literalinclude} ../../unilabos_msgs/action/Purge.action
+:language: yaml
+```
+
+---
+
+### `Recrystallize`
+
+```{literalinclude} ../../unilabos_msgs/action/Recrystallize.action
+:language: yaml
+```
+
+---
+
+### `RunColumn`
+
+```{literalinclude} ../../unilabos_msgs/action/RunColumn.action
+:language: yaml
+```
+
+---
+
+### `StartPurge`
+
+```{literalinclude} ../../unilabos_msgs/action/StartPurge.action
+:language: yaml
+```
+
+---
+
+### `StartStir`
+
+```{literalinclude} ../../unilabos_msgs/action/StartStir.action
+:language: yaml
+```
+
+---
+
+### `StopPurge`
+
+```{literalinclude} ../../unilabos_msgs/action/StopPurge.action
+:language: yaml
+```
+
+---
+
+### `StopStir`
+
+```{literalinclude} ../../unilabos_msgs/action/StopStir.action
+:language: yaml
+```
+
+---
+
+### `Transfer`
+
+```{literalinclude} ../../unilabos_msgs/action/Transfer.action
+:language: yaml
+```
+
+---
+
+### `WashSolid`
+
+```{literalinclude} ../../unilabos_msgs/action/WashSolid.action
+:language: yaml
+```
+
+---
+
 ## 移液工作站及相关生物自动化设备操作
 
 Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.org/user_guide/index.html)，包含生物实验中常见的操作，如移液、混匀、离心等。
 
-
-
 ### `LiquidHandlerAspirate`
 
 ```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerAspirate.action
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerDiscardTips`
 
@@ -105,7 +302,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerDispense`
 
@@ -113,7 +310,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerDropTips`
 
@@ -121,7 +318,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerDropTips96`
 
@@ -129,7 +326,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerMoveLid`
 
@@ -137,7 +334,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerMovePlate`
 
@@ -145,7 +342,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerMoveResource`
 
@@ -153,7 +350,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerPickUpTips`
 
@@ -161,7 +358,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerPickUpTips96`
 
@@ -169,7 +366,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerReturnTips`
 
@@ -177,7 +374,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerReturnTips96`
 
@@ -185,7 +382,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerStamp`
 
@@ -193,7 +390,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `LiquidHandlerTransfer`
 
@@ -201,9 +398,113 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
-## 多工作站及小车运行、物料转移
+---
 
+### `LiquidHandlerAdd`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerAdd.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerIncubateBiomek`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerIncubateBiomek.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerMix`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerMix.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerMoveBiomek`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerMoveBiomek.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerMoveTo`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerMoveTo.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerOscillateBiomek`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerOscillateBiomek.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerProtocolCreation`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerProtocolCreation.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerRemove`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerRemove.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerSetGroup`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerSetGroup.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerSetLiquid`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerSetLiquid.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerSetTipRack`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerSetTipRack.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerTransferBiomek`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerTransferBiomek.action
+:language: yaml
+```
+
+---
+
+### `LiquidHandlerTransferGroup`
+
+```{literalinclude} ../../unilabos_msgs/action/LiquidHandlerTransferGroup.action
+:language: yaml
+```
+
+---
+
+## 多工作站及小车运行、物料转移
 
 ### `AGVTransfer`
 
@@ -211,7 +512,7 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
 
 ### `WorkStationRun`
 
@@ -219,12 +520,64 @@ Uni-Lab 生物操作指令集多数来自 [PyLabRobot](https://docs.pylabrobot.o
 :language: yaml
 ```
 
-----
+---
+
+### `ResetHandling`
+
+```{literalinclude} ../../unilabos_msgs/action/ResetHandling.action
+:language: yaml
+```
+
+---
+
+### `ResourceCreateFromOuter`
+
+```{literalinclude} ../../unilabos_msgs/action/ResourceCreateFromOuter.action
+:language: yaml
+```
+
+---
+
+### `ResourceCreateFromOuterEasy`
+
+```{literalinclude} ../../unilabos_msgs/action/ResourceCreateFromOuterEasy.action
+:language: yaml
+```
+
+---
+
+### `SetPumpPosition`
+
+```{literalinclude} ../../unilabos_msgs/action/SetPumpPosition.action
+:language: yaml
+```
+
+---
+
+## 固体分配与处理设备操作
+
+### `SolidDispenseAddPowderTube`
+
+```{literalinclude} ../../unilabos_msgs/action/SolidDispenseAddPowderTube.action
+:language: yaml
+```
+
+---
+
+## 其他设备操作
+
+### `EmptyIn`
+
+```{literalinclude} ../../unilabos_msgs/action/EmptyIn.action
+:language: yaml
+```
+
+---
+
 ## 机械臂、夹爪等机器人设备
 
 Uni-Lab 机械臂、机器人、夹爪和导航指令集沿用 ROS2 的 `control_msgs` 和 `nav2_msgs`：
 
-
 ### `FollowJointTrajectory`
 
 ```yaml
@@ -292,7 +645,8 @@ trajectory_msgs/MultiDOFJointTrajectoryPoint multi_dof_error
 
 ```
 
-----
+---
+
 ### `GripperCommand`
 
 ```yaml
@@ -310,17 +664,19 @@ bool reached_goal # True iff the gripper position has reached the commanded setp
 
 ```
 
-----
+---
+
 ### `JointTrajectory`
 
 ```yaml
 trajectory_msgs/JointTrajectory trajectory
 ---
----
 
+---
 ```
 
-----
+---
+
 ### `PointHead`
 
 ```yaml
@@ -330,12 +686,13 @@ string pointing_frame
 builtin_interfaces/Duration min_duration
 float64 max_velocity
 ---
+
 ---
 float64 pointing_angle_error
-
 ```
 
-----
+---
+
 ### `SingleJointPosition`
 
 ```yaml
@@ -343,15 +700,16 @@ float64 position
 builtin_interfaces/Duration min_duration
 float64 max_velocity
 ---
+
 ---
 std_msgs/Header header
 float64 position
 float64 velocity
 float64 error
-
 ```
 
-----
+---
+
 ### `AssistedTeleop`
 
 ```yaml
@@ -363,10 +721,10 @@ builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback
 builtin_interfaces/Duration current_teleop_duration
-
 ```
 
-----
+---
+
 ### `BackUp`
 
 ```yaml
@@ -380,10 +738,10 @@ builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback definition
 float32 distance_traveled
-
 ```
 
-----
+---
+
 ### `ComputePathThroughPoses`
 
 ```yaml
@@ -398,10 +756,10 @@ nav_msgs/Path path
 builtin_interfaces/Duration planning_time
 ---
 #feedback definition
-
 ```
 
-----
+---
+
 ### `ComputePathToPose`
 
 ```yaml
@@ -416,10 +774,10 @@ nav_msgs/Path path
 builtin_interfaces/Duration planning_time
 ---
 #feedback definition
-
 ```
 
-----
+---
+
 ### `DriveOnHeading`
 
 ```yaml
@@ -433,10 +791,10 @@ builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback definition
 float32 distance_traveled
-
 ```
 
-----
+---
+
 ### `DummyBehavior`
 
 ```yaml
@@ -447,10 +805,10 @@ std_msgs/String command
 builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback definition
-
 ```
 
-----
+---
+
 ### `FollowPath`
 
 ```yaml
@@ -465,10 +823,10 @@ std_msgs/Empty result
 #feedback definition
 float32 distance_to_goal
 float32 speed
-
 ```
 
-----
+---
+
 ### `FollowWaypoints`
 
 ```yaml
@@ -480,10 +838,10 @@ int32[] missed_waypoints
 ---
 #feedback definition
 uint32 current_waypoint
-
 ```
 
-----
+---
+
 ### `NavigateThroughPoses`
 
 ```yaml
@@ -501,10 +859,10 @@ builtin_interfaces/Duration estimated_time_remaining
 int16 number_of_recoveries
 float32 distance_remaining
 int16 number_of_poses_remaining
-
 ```
 
-----
+---
+
 ### `NavigateToPose`
 
 ```yaml
@@ -521,10 +879,10 @@ builtin_interfaces/Duration navigation_time
 builtin_interfaces/Duration estimated_time_remaining
 int16 number_of_recoveries
 float32 distance_remaining
-
 ```
 
-----
+---
+
 ### `SmoothPath`
 
 ```yaml
@@ -540,10 +898,10 @@ builtin_interfaces/Duration smoothing_duration
 bool was_completed
 ---
 #feedback definition
-
 ```
 
-----
+---
+
 ### `Spin`
 
 ```yaml
@@ -556,10 +914,10 @@ builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback definition
 float32 angular_distance_traveled
-
 ```
 
-----
+---
+
 ### `Wait`
 
 ```yaml
@@ -571,7 +929,6 @@ builtin_interfaces/Duration total_elapsed_time
 ---
 #feedback definition
 builtin_interfaces/Duration time_left
-
 ```
 
-----
+---

docs/developer_guide/add_action.md

@@ -1,37 +1,142 @@
 # 添加新动作指令（Action）
 
-1. 在 `unilabos_msgs/action` 中新建实验操作名和参数列表，如 `MyDeviceCmd.action`。一个 Action 定义由三个部分组成，分别是目标（Goal）、结果（Result）和反馈（Feedback），之间使用 `---` 分隔：
+本指南将引导你完成添加新动作指令的整个流程，包括编写、在线构建和测试。
+
+## 1. 编写新的 Action
+
+### 1.1 创建 Action 文件
+
+在 `unilabos_msgs/action` 目录中新建实验操作文件，如 `MyDeviceCmd.action`。一个 Action 定义由三个部分组成，分别是目标（Goal）、结果（Result）和反馈（Feedback），之间使用 `---` 分隔：
 
 ```action
-# 目标（Goal）
+# 目标（Goal）- 定义动作执行所需的参数
 string command
+float64 timeout
 ---
-# 结果（Result）
-bool success
+# 结果（Result）- 定义动作完成后返回的结果
+bool success  # 要求必须包含success，以便回传执行结果
+string return_info  # 要求必须包含return_info，以便回传执行结果
+...  # 其他
 ---
-# 反馈（Feedback）
+# 反馈（Feedback）- 定义动作执行过程中的反馈信息
+float64 progress
+string status
 ```
 
-2. 在 `unilabos_msgs/CMakeLists.txt` 中添加新定义的 action
+### 1.2 更新 CMakeLists.txt
+
+在 `unilabos_msgs/CMakeLists.txt` 中的 `add_action_files()` 部分添加新定义的 action：
 
 ```cmake
 add_action_files(
   FILES
   MyDeviceCmd.action
+  # 其他已有的 action 文件...
 )
 ```
 
-3. 因为在指令集中新建了指令，因此调试时需要编译，并在终端环境中加载临时路径：
+## 2. 在线构建和测试
+
+为了简化开发流程并确保构建环境的一致性，我们使用 GitHub Actions 进行在线构建。
+
+### 2.1 Fork 仓库并创建分支
+
+1. **Fork 仓库**：在 GitHub 上 fork `Uni-Lab-OS` 仓库到你的个人账户
+
+2. **Clone 你的 fork**：
+
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/Uni-Lab-OS.git
+   cd Uni-Lab-OS
+   ```
+
+3. **创建功能分支**：
+
+   ```bash
+   git checkout -b add-my-device-action
+   ```
+
+4. **提交你的更改**：
+   ```bash
+   git add unilabos_msgs/action/MyDeviceCmd.action
+   git add unilabos_msgs/CMakeLists.txt
+   git commit -m "Add MyDeviceCmd action for device control"
+   git push origin add-my-device-action
+   ```
+
+### 2.2 触发在线构建
+
+1. **访问你的 fork 仓库**：在浏览器中打开你的 fork 仓库页面
+
+2. **手动触发构建**：
+
+   - 点击 "Actions" 标签
+   - 选择 "Multi-Platform Conda Build" 工作流
+   - 点击 "Run workflow" 按钮
+
+3. **监控构建状态**：
+   - 构建过程大约需要 5-10 分钟
+   - 在 Actions 页面可以实时查看构建日志
+   - 构建完成后，可以下载生成的 conda 包进行测试
+
+### 2.3 下载和测试构建包
+
+1. **下载构建产物**：
+
+   - 在构建完成的 Action 页面，找到 "Artifacts" 部分
+   - 下载对应平台的 `conda-package-*` 文件
+
+2. **本地测试安装**：
+
+   ```bash
+   # 解压下载的构建产物
+   unzip conda-package-linux-64.zip  # 或其他平台
+
+   # 安装测试包
+   mamba install ./ros-humble-unilabos-msgs-*.conda
+   ```
+
+3. **验证 Action 是否正确添加**：
+   ```bash
+   # 检查 action 是否可用
+   ros2 interface show unilabos_msgs/action/MyDeviceCmd
+   ```
+
+## 3. 提交 Pull Request
+
+测试成功后，向主仓库提交 Pull Request：
+
+1. **创建 Pull Request**：
+
+   - 在你的 fork 仓库页面，点击 "New Pull Request"
+   - 选择你的功能分支作为源分支
+   - 填写详细的 PR 描述，包括：
+     - 添加的 Action 功能说明
+     - 测试结果
+     - 相关的设备或用例
+
+2. **等待审核和合并**：
+   - 维护者会审核你的代码
+   - CI/CD 系统会自动运行完整的测试套件
+   - 合并后，新的指令集会自动发布到官方 conda 仓库
+
+## 4. 使用新的 Action
+
+如果采用自己构建的action包，可以通过以下命令更新安装：
 
 ```bash
-cd unilabos_msgs
-colcon build
-source ./install/local_setup.sh
-cd ..
+mamba remove --force ros-humble-unilabos-msgs
+mamba config set safety_checks disabled  # 如果没有提升版本号，会触发md5与网络上md5不一致，是正常现象，因此通过本指令关闭md5检查
+mamba install xxx.conda --offline
 ```
 
-调试成功后，发起 pull request，Uni-Lab 的 CI/CD 系统会自动将新的指令集编译打包，mamba执行升级即可永久生效：
+## 常见问题
 
-```bash
-mamba update ros-humble-unilabos-msgs -c http://quetz.dp.tech:8088/get/unilab -c robostack-humble -c robostack-staging
-```
+**Q: 构建失败怎么办？**
+A: 检查 Actions 日志中的错误信息，通常是语法错误或依赖问题。修复后重新推送代码即可自动触发新的构建。
+
+**Q: 如何测试特定平台？**
+A: 在手动触发构建时，在平台选择中只填写你需要的平台，如 `linux-64` 或 `win-64`。
+
+**Q: 构建包在哪里下载？**
+A: 在 Actions 页面的构建结果中，查找 "Artifacts" 部分，每个平台都有对应的构建包可供下载。

docs/developer_guide/add_device.md

@@ -94,107 +94,61 @@ public class MockGripper
 
 C# 驱动设备在完成注册表后，需要调用 Uni-Lab C# 编译后才能使用，但只需一次。
 
-## 注册表文件位置
+## 快速开始：使用注册表编辑器（推荐）
 
-Uni-Lab 启动时会自动读取默认注册表路径 `unilabos/registry/devices` 下的所有注册设备。您也可以任意维护自己的注册表路径，只需要在 Uni-Lab 启动时使用 `--registry` 参数将路径添加即可。
+推荐使用 Uni-Lab-OS 自带的可视化编辑器，它能自动分析您的设备驱动并生成大部分配置：
 
-在 `<path-to-registry>/devices` 中新建一个 yaml 文件，即可开始撰写。您可以将多个设备写到同一个 yaml 文件中。
+1. 启动 Uni-Lab-OS
+2. 在浏览器中打开"注册表编辑器"页面
+3. 选择您的 Python 设备驱动文件
+4. 点击"分析文件"，让系统读取类信息
+5. 填写基本信息（设备描述、图标等）
+6. 点击"生成注册表"，复制生成的内容
+7. 保存到 `devices/` 目录下
 
-## 注册表的结构
+---
 
-1. 顶层名称：每个设备的注册表以设备名称开头，例如 `new_device`, `gripper.mock`。
-1. `class` 字段：定义设备的模块路径和驱动程序语言。
-1. `status_types` 字段：定义设备定时对 Uni-Lab 实验室内发送的属性名及其类型。
-1. `action_value_mappings` 字段：定义设备支持的动作及其目标、反馈和结果。
-1. `schema` 字段：定义设备定时对 Uni-Lab 云端监控发送的属性名及其类型、描述（非必须）
+## 手动编写注册表（简化版）
 
-## 创建新的注册表教程
+如果需要手动编写，只需要提供两个必需字段，系统会自动补全其余内容：
 
-1. 创建文件
-   在 devices 文件夹中创建一个新的 YAML 文件，例如 `new_device.yaml`。
-2. 定义设备名称
-   在文件中定义设备的顶层名称，例如：`new_device` 或 `gripper.mock`
-3. 定义设备的类信息
-   添加设备的模块路径和类型：
+### 最小配置示例
 
 ```yaml
-gripper.mock:
-  class:   # 定义设备的类信息
-    module: unilabos.devices.gripper.mock:MockGripper
-    type: python  # 指定驱动语言为 Python
-    status_types:
-      position: Float64
-      torque: Float64
-      status: String
+my_device: # 设备唯一标识符
+  class:
+    module: unilabos.devices.your_module.my_device:MyDevice # Python 类路径
+    type: python # 驱动类型
 ```
 
-4. 定义设备的定时发布属性。注意，对于 Python Class 来说，PROP 是 class 的 `property`，或满足能被 `getattr(cls, PROP)` 或 `cls.get_PROP` 读取到的属性值的对象。
+### 注册表文件位置
+
+- 默认路径：`unilabos/registry/devices`
+- 自定义路径：启动时使用 `--registry` 参数指定
+- 可将多个设备写在同一个 yaml 文件中
+
+### 系统自动生成的内容
+
+系统会自动分析您的 Python 驱动类并生成：
+
+- `status_types`：从 `get_*` 方法自动识别状态属性
+- `action_value_mappings`：从类方法自动生成动作映射
+- `init_param_schema`：从 `__init__` 方法分析初始化参数
+- `schema`：前端显示用的属性类型定义
+
+### 完整结构概览
 
 ```yaml
-    status_types:
-      PROP: TYPE
-```
-5. 定义设备支持的动作
-   添加设备支持的动作及其目标、反馈和结果：
-
-```yaml
-    action_value_mappings:
-      set_speed:
-        type: SendCmd
-        goal:
-          command: speed
-        feedback: {}
-        result:
-          success: success
+my_device:
+  class:
+    module: unilabos.devices.your_module.my_device:MyDevice
+    type: python
+    status_types: {} # 自动生成
+    action_value_mappings: {} # 自动生成
+  description: '' # 可选：设备描述
+  icon: '' # 可选：设备图标
+  init_param_schema: {} # 自动生成
+  schema: {} # 自动生成
 ```
 
-在 devices 文件夹中的 YAML 文件中，action_value_mappings 是用来将驱动内的动作函数，映射到 Uni-Lab 标准动作（actions）及其目标参数值（goal）、反馈值（feedback）和结果值（result）的映射规则。若在 Uni-Lab 指令集内找不到符合心意的，请【创建新指令】。
-
-```yaml
-  action_value_mappings:
-    <action_name>:                      # <action_name>：动作的名称
-                                        # start：启动设备或某个功能。
-                                        # stop：停止设备或某个功能。
-                                        # set_speed：设置设备的速度。
-                                        # set_temperature：设置设备的温度。
-                                        # move_to_position：移动设备到指定位置。
-                                        # stir：执行搅拌操作。
-                                        # heatchill：执行加热或冷却操作。
-                                        # send_nav_task：发送导航任务（例如机器人导航）。
-                                        # set_timer：设置设备的计时器。
-                                        # valve_open_cmd：打开阀门。
-                                        # valve_close_cmd：关闭阀门。
-                                        # execute_command_from_outer：执行外部命令。
-                                        # push_to：控制设备推送到某个位置（例如机械爪）。
-                                        # move_through_points：导航设备通过多个点。
-
-      type: <ActionType>                # 动作的类型，表示动作的功能
-                                        # 根据动作的功能选择合适的类型，请查阅 Uni-Lab 已支持的指令集。
-
-      goal:                             # 定义动作的目标值映射，表示需要传递给设备的参数。
-        <goal_key>: <mapped_value>      #确定设备需要的输入参数，并将其映射到设备的字段。
-
-      feedback:                         # 定义动作的反馈值映射，表示设备执行动作时返回的实时状态。
-        <feedback_key>: <mapped_value>
-      result:                           # 定义动作的结果值映射，表示动作完成后返回的最终结果。
-        <result_key>: <mapped_value>
-```
-
-6. 定义设备的网页展示属性类型，这部分会被用于在 Uni-Lab 网页端渲染成状态监控
-   添加设备的属性模式，包括属性类型和描述：
-
-```yaml
-schema:
-    type: object
-    properties:
-      status:
-        type: string
-        description: The status of the device
-      speed:
-        type: number
-        description: The speed of the device
-    required:
-      - status
-      - speed
-    additionalProperties: false
-```
+详细的注册表编写指南和高级配置，请参考{doc}`yaml 注册表编写指南 <add_yaml>`。

docs/developer_guide/add_yaml.md

@@ -1,95 +1,610 @@
-# yaml注册表编写指南
+# yaml 注册表编写指南
 
-`注册表的结构`
+## 快速开始：使用注册表编辑器
 
-1. 顶层名称：每个设备的注册表以设备名称开头，例如 new_device。
-2. class 字段：定义设备的模块路径和类型。
-3. schema 字段：定义设备的属性模式，包括属性类型、描述和必需字段。
-4. action_value_mappings 字段：定义设备支持的动作及其目标、反馈和结果。
+推荐使用 UniLabOS 自带的可视化编辑器，它能帮你自动生成大部分配置，省去手写的麻烦。
 
-`创建新的注册表教程`
-1. 创建文件
-    在 devices 文件夹中创建一个新的 YAML 文件，例如 new_device.yaml。
+### 怎么用编辑器
 
-2. 定义设备名称
-    在文件中定义设备的顶层名称，例如：new_device
+1. 启动 UniLabOS
+2. 在浏览器中打开"注册表编辑器"页面
+3. 选择你的 Python 设备驱动文件
+4. 点击"分析文件"，让系统读取你的类信息
+5. 填写一些基本信息（设备描述、图标啥的）
+6. 点击"生成注册表"，复制生成的内容
+7. 把内容保存到 `devices/` 目录下
 
-3. 定义设备的类信息
-    添加设备的模块路径和类型：
+我们为你准备了一个测试驱动，用于在界面上尝试注册表生成，参见目录：test\registry\example_devices.py
 
-```python
-new_device:  # 定义一个名为 linear_motion.grbl 的设备
+---
 
+## 手动编写指南
 
-class:  # 定义设备的类信息
-    module: unilabos.devices_names.new_device:NewDeviceClass  # 指定模块路径和类名
-    type: python  # 指定类型为 Python 类
-    status_types:
-```
-4. 定义设备支持的动作
-    添加设备支持的动作及其目标、反馈和结果：
-```python
-  action_value_mappings:
-    set_speed:
-      type: SendCmd
-      goal:
-        command: speed
-      feedback: {}
-      result:
-        success: success
-```
-`如何编写action_valve_mappings`
-1. 在 devices 文件夹中的 YAML 文件中，action_value_mappings 是用来定义设备支持的动作（actions）及其目标值（goal）、反馈值（feedback）和结果值（result）的映射规则。以下是规则和编写方法：
-```python
-  action_value_mappings:
-    <action_name>:                      # <action_name>：动作的名称
-                                        # start：启动设备或某个功能。
-                                        # stop：停止设备或某个功能。
-                                        # set_speed：设置设备的速度。
-                                        # set_temperature：设置设备的温度。
-                                        # move_to_position：移动设备到指定位置。
-                                        # stir：执行搅拌操作。
-                                        # heatchill：执行加热或冷却操作。
-                                        # send_nav_task：发送导航任务（例如机器人导航）。
-                                        # set_timer：设置设备的计时器。
-                                        # valve_open_cmd：打开阀门。
-                                        # valve_close_cmd：关闭阀门。
-                                        # execute_command_from_outer：执行外部命令。
-                                        # push_to：控制设备推送到某个位置（例如机械爪）。
-                                        # move_through_points：导航设备通过多个点。
+如果你想自己写 yaml 文件，或者想深入了解结构，查阅下方说明。
 
-      type: <ActionType>                # 动作的类型，表示动作的功能
-                                        # 根据动作的功能选择合适的类型：
-                                        # SendCmd：发送简单命令。
-                                        # NavigateThroughPoses：导航动作。
-                                        # SingleJointPosition：设置单一关节的位置。
-                                        # Stir：搅拌动作。
-                                        # HeatChill：加热或冷却动作。
+## 注册表的基本结构
 
-      goal:                             # 定义动作的目标值映射，表示需要传递给设备的参数。
-        <goal_key>: <mapped_value>      #确定设备需要的输入参数，并将其映射到设备的字段。
+yaml 注册表就是设备的配置文件，里面定义了设备怎么用、有什么功能。好消息是系统会自动帮你填大部分内容，你只需要写两个必需的东西：设备名和 class 信息。
 
-      feedback:                         # 定义动作的反馈值映射，表示设备执行动作时返回的实时状态。
-        <feedback_key>: <mapped_value>
-      result:                           # 定义动作的结果值映射，表示动作完成后返回的最终结果。
-        <result_key>: <mapped_value>
+### 各字段用途
+
+| 字段名            | 类型   | 需要手写 | 说明                                |
+| ----------------- | ------ | -------- | ----------------------------------- |
+| 设备标识符        | string | 是       | 设备的唯一名字，比如 `mock_chiller` |
+| class             | object | 部分     | 设备的核心信息，必须写              |
+| description       | string | 否       | 设备描述，系统默认给空字符串        |
+| handles           | array  | 否       | 连接关系，默认是空的                |
+| icon              | string | 否       | 图标路径，默认为空                  |
+| init_param_schema | object | 否       | 初始化参数，系统自动分析生成        |
+| version           | string | 否       | 版本号，默认 "1.0.0"                |
+| category          | array  | 否       | 设备分类，默认用文件名              |
+| config_info       | array  | 否       | 嵌套配置，默认为空                  |
+| file_path         | string | 否       | 文件路径，系统自动设置              |
+| registry_type     | string | 否       | 注册表类型，自动设为 "device"       |
+
+### class 字段里有啥
+
+class 是核心部分，包含这些内容：
+
+| 字段名                | 类型   | 需要手写 | 说明                               |
+| --------------------- | ------ | -------- | ---------------------------------- |
+| module                | string | 是       | Python 类的路径，必须写            |
+| type                  | string | 是       | 驱动类型，一般写 "python"          |
+| status_types          | object | 否       | 状态类型，系统自动分析生成         |
+| action_value_mappings | object | 部分     | 动作配置，系统会自动生成一些基础的 |
+
+## 怎么创建新的注册表
+
+### 创建文件
+
+在 devices 文件夹里新建一个 yaml 文件，比如 `new_device.yaml`。
+
+### 完整结构是什么样的
+
+```yaml
+new_device: # 设备名，要唯一
+  class: # 核心配置
+    action_value_mappings: # 动作配置（后面会详细说）
+      action_name:
+        # 具体的动作设置
+    module: unilabos.devices.your_module.new_device:NewDeviceClass # 你的 Python 类
+    status_types: # 状态类型（系统会自动生成）
+      status: str
+      temperature: float
+      # 其他状态
+    type: python # 驱动类型，一般就是 python
+
+  description: New Device Description # 设备描述
+  handles: [] # 连接关系，通常是空的
+  icon: '' # 图标路径
+  init_param_schema: # 初始化参数（系统会自动生成）
+    config: # 初始化时需要的参数
+      properties:
+        port:
+          default: DEFAULT_PORT
+          type: string
+      required: []
+      type: object
+    data: # 前端显示用的数据类型
+      properties:
+        status:
+          type: string
+        temperature:
+          type: number
+      required:
+        - status
+      type: object
+
+  version: 0.0.1 # 版本号
+  category:
+    - device_category # 设备类别
+  config_info: [] # 嵌套配置，通常为空
 ```
 
-6. 定义设备的属性模式
-    添加设备的属性模式，包括属性类型和描述：
-```python
-schema:
-    type: object
+## action_value_mappings 怎么写
+
+这个部分定义设备能做哪些动作。好消息是系统会自动生成大部分动作，你通常只需要添加一些特殊的自定义动作。
+
+### 系统自动生成哪些动作
+
+系统会帮你生成这些：
+
+1. 以 `auto-` 开头的动作：从你 Python 类的方法自动生成
+2. 通用的驱动动作：
+   - `_execute_driver_command`：同步执行驱动命令
+   - `_execute_driver_command_async`：异步执行驱动命令
+
+### 如果要手动定义动作
+
+如果你需要自定义一些特殊动作，需要这些字段：
+
+| 字段名           | 需要手写 | 说明                             |
+| ---------------- | -------- | -------------------------------- |
+| type             | 是       | 动作类型，必须指定               |
+| goal             | 是       | 输入参数怎么映射                 |
+| feedback         | 否       | 实时反馈，通常为空               |
+| result           | 是       | 结果怎么返回                     |
+| goal_default     | 部分     | 参数默认值，ROS 动作会自动生成   |
+| schema           | 部分     | 前端表单配置，ROS 动作会自动生成 |
+| handles          | 否       | 连接关系，默认为空               |
+| placeholder_keys | 否       | 特殊输入字段配置                 |
+
+### 动作类型有哪些
+
+| 类型                   | 什么时候用           | 系统会自动生成什么     |
+| ---------------------- | -------------------- | ---------------------- |
+| UniLabJsonCommand      | 自定义同步 JSON 命令 | 啥都不生成             |
+| UniLabJsonCommandAsync | 自定义异步 JSON 命令 | 啥都不生成             |
+| ROS 动作类型           | 标准 ROS 动作        | goal_default 和 schema |
+
+常用的 ROS 动作类型：
+
+- `SendCmd`：发送简单命令
+- `NavigateThroughPoses`：导航动作
+- `SingleJointPosition`：单关节位置控制
+- `Stir`：搅拌动作
+- `HeatChill`、`HeatChillStart`：加热冷却动作
+
+### 复杂一点的例子
+
+```yaml
+heat_chill_start:
+  type: HeatChillStart
+  goal:
+    purpose: purpose
+    temp: temp
+  goal_default: # ROS动作会自动生成，你也可以手动覆盖
+    purpose: ''
+    temp: 0.0
+  handles:
+    output:
+      - handler_key: labware
+        label: Labware
+        data_type: resource
+        data_source: handle
+        data_key: liquid
+  placeholder_keys:
+    purpose: unilabos_resources
+  result:
+    status: status
+    success: success
+  # schema 系统会自动生成，不用写
+```
+
+### 动作名字怎么起
+
+根据设备用途来起名字：
+
+- 启动停止类：`start`、`stop`、`pause`、`resume`
+- 设置参数类：`set_speed`、`set_temperature`、`set_timer`
+- 移动控制类：`move_to_position`、`move_through_points`
+- 功能操作类：`stir`、`heat_chill_start`、`heat_chill_stop`
+- 开关控制类：`valve_open_cmd`、`valve_close_cmd`、`push_to`
+- 命令执行类：`send_nav_task`、`execute_command_from_outer`
+
+### 常用的动作类型
+
+- `UniLabJsonCommand`：自定义 JSON 命令（不走 ROS）
+- `UniLabJsonCommandAsync`：异步 JSON 命令（不走 ROS）
+- `SendCmd`：发送简单命令
+- `NavigateThroughPoses`：导航相关
+- `SingleJointPosition`：单关节控制
+- `Stir`：搅拌
+- `HeatChill`、`HeatChillStart`：加热冷却
+- 其他的 ROS 动作类型：看具体的 ROS 服务
+
+### 示例：完整的动作配置
+
+```yaml
+heat_chill_start:
+  type: HeatChillStart
+  goal:
+    purpose: purpose
+    temp: temp
+  goal_default:
+    purpose: ''
+    temp: 0.0
+  handles:
+    output:
+      - handler_key: labware
+        label: Labware
+        data_type: resource
+        data_source: handle
+        data_key: liquid
+  placeholder_keys:
+    purpose: unilabos_resources
+  result:
+    status: status
+    success: success
+  schema:
+    description: '启动加热冷却功能'
     properties:
+      goal:
+        properties:
+          purpose:
+            type: string
+            description: '用途说明'
+          temp:
+            type: number
+            description: '目标温度'
+        required:
+          - purpose
+          - temp
+        title: HeatChillStart_Goal
+        type: object
+    required:
+      - goal
+    title: HeatChillStart
+    type: object
+  feedback: {}
+```
+
+## 系统自动生成的字段
+
+### status_types
+
+系统会扫描你的 Python 类，从状态方法自动生成这部分：
+
+```yaml
+status_types:
+  current_temperature: float # 从 get_current_temperature() 方法来的
+  is_heating: bool # 从 get_is_heating() 方法来的
+  status: str # 从 get_status() 方法来的
+```
+
+注意几点：
+
+- 系统会找所有 `get_` 开头的方法
+- 类型会自动转成 ROS 类型（比如 `str` 变成 `String`）
+- 如果类型是 `Any`、`None` 或者不知道的，就默认用 `String`
+
+### init_param_schema
+
+这个完全是系统自动生成的，你不用管：
+
+```yaml
+init_param_schema:
+  config: # 从你类的 __init__ 方法分析出来的
+    properties:
+      port:
+        type: string
+        default: '/dev/ttyUSB0'
+      baudrate:
+        type: integer
+        default: 9600
+    required: []
+    type: object
+
+  data: # 根据 status_types 生成的前端用的类型
+    properties:
+      current_temperature:
+        type: number
+      is_heating:
+        type: boolean
       status:
         type: string
-        description: The status of the device
-      speed:
-        type: number
-        description: The speed of the device
     required:
       - status
-      - speed
-    additionalProperties: false
+    type: object
 ```
-# 写完yaml注册表后需要添加到哪些其他文件？
+
+生成规则很简单：
+
+- `config` 部分：看你类的 `__init__` 方法有什么参数，类型和默认值是啥
+- `data` 部分：根据 `status_types` 生成前端显示用的类型定义
+
+### 其他自动填充的字段
+
+```yaml
+version: '1.0.0' # 默认版本
+category: ['文件名'] # 用你的 yaml 文件名当类别
+description: '' # 默认为空，你可以手动改
+icon: '' # 默认为空，你可以加图标
+handles: [] # 默认空数组
+config_info: [] # 默认空数组
+file_path: '/path/to/file' # 系统自动填文件路径
+registry_type: 'device' # 自动设为设备类型
+```
+
+### handles 字段
+
+这个是定义设备连接关系的，类似动作里的 handles 一样：
+
+```yaml
+handles: # 大多数时候都是空的，除非设备本身需要连接啥
+  - handler_key: device_output
+    label: Device Output
+    data_type: resource
+    data_source: value
+    data_key: default_value
+```
+
+### 其他可以配置的字段
+
+```yaml
+description: '设备的详细描述' # 写清楚设备是干啥的
+
+icon: 'device_icon.webp' # 设备图标，文件名（会上传到OSS）
+
+version: '0.0.1' # 版本号
+
+category: # 设备分类，前端会用这个分组
+  - 'heating'
+  - 'cooling'
+  - 'temperature_control'
+
+config_info: # 嵌套配置，如果设备包含子设备
+  - children:
+      - opentrons_24_tuberack_nest_1point5ml_snapcap_A1
+      - other_nested_component
+```
+
+## 完整的例子
+
+这里是一个比较完整的设备配置示例：
+
+```yaml
+my_temperature_controller:
+  class:
+    action_value_mappings:
+      heat_start:
+        type: HeatChillStart
+        goal:
+          target_temp: temp
+          vessel: vessel
+        goal_default:
+          target_temp: 25.0
+          vessel: ''
+        handles:
+          output:
+            - handler_key: heated_sample
+              label: Heated Sample
+              data_type: resource
+              data_source: handle
+              data_key: sample
+        placeholder_keys:
+          vessel: unilabos_resources
+        result:
+          status: status
+          success: success
+        schema:
+          description: '启动加热功能'
+          properties:
+            goal:
+              properties:
+                target_temp:
+                  type: number
+                  description: '目标温度'
+                vessel:
+                  type: string
+                  description: '容器标识'
+              required:
+                - target_temp
+                - vessel
+              title: HeatStart_Goal
+              type: object
+          required:
+            - goal
+          title: HeatStart
+          type: object
+        feedback: {}
+
+      stop:
+        type: UniLabJsonCommand
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result:
+          status: status
+        schema:
+          description: '停止设备'
+          properties:
+            goal:
+              type: object
+              title: Stop_Goal
+          title: Stop
+          type: object
+        feedback: {}
+
+    module: unilabos.devices.temperature.my_controller:MyTemperatureController
+    status_types:
+      current_temperature: float
+      target_temperature: float
+      is_heating: bool
+      is_cooling: bool
+      status: str
+      vessel: str
+    type: python
+
+  description: '我的温度控制器设备'
+  handles: []
+  icon: 'temperature_controller.webp'
+  init_param_schema:
+    config:
+      properties:
+        port:
+          default: '/dev/ttyUSB0'
+          type: string
+        baudrate:
+          default: 9600
+          type: number
+      required: []
+      type: object
+    data:
+      properties:
+        current_temperature:
+          type: number
+        target_temperature:
+          type: number
+        is_heating:
+          type: boolean
+        is_cooling:
+          type: boolean
+        status:
+          type: string
+        vessel:
+          type: string
+      required:
+        - current_temperature
+        - target_temperature
+        - status
+      type: object
+
+  version: '1.0.0'
+  category:
+    - 'temperature_control'
+    - 'heating'
+  config_info: []
+```
+
+## 怎么部署和使用
+
+### 方法一：用编辑器（推荐）
+
+1. 先写好你的 Python 驱动类
+2. 用注册表编辑器自动生成 yaml 配置
+3. 把生成的文件保存到 `devices/` 目录
+4. 重启 UniLabOS 就能用了
+
+### 方法二：手动写（简化版）
+
+1. 创建最简配置：
+
+```yaml
+# devices/my_device.yaml
+my_device:
+  class:
+    module: unilabos.devices.my_module.my_device:MyDevice
+    type: python
+```
+
+2. 启动系统时用 `complete_registry=True` 参数，让系统自动补全
+
+3. 检查一下生成的配置是不是你想要的
+
+### Python 驱动类要怎么写
+
+你的设备类要符合这些要求：
+
+```python
+from unilabos.common.device_base import DeviceBase
+
+class MyDevice(DeviceBase):
+    def __init__(self, config):
+        """初始化，参数会自动分析到 init_param_schema.config"""
+        super().__init__(config)
+        self.port = config.get('port', '/dev/ttyUSB0')
+
+    # 状态方法（会自动生成到 status_types）
+    def get_status(self):
+        """返回设备状态"""
+        return "idle"
+
+    def get_temperature(self):
+        """返回当前温度"""
+        return 25.0
+
+    # 动作方法（会自动生成 auto- 开头的动作）
+    async def start_heating(self, temperature: float):
+        """开始加热到指定温度"""
+        pass
+
+    def stop(self):
+        """停止操作"""
+        pass
+```
+
+### 系统集成
+
+1. 把 yaml 文件放到 `devices/` 目录下
+2. 系统启动时会自动扫描并加载设备
+3. 系统会自动补全所有缺失的字段
+4. 设备马上就能在前端界面中使用
+
+### 高级配置
+
+如果需要特殊设置，可以手动加：
+
+```yaml
+my_device:
+  class:
+    module: unilabos.devices.my_module.my_device:MyDevice
+    type: python
+    action_value_mappings:
+      # 自定义动作
+      special_command:
+        type: UniLabJsonCommand
+        goal: {}
+        result: {}
+
+  # 可选的自定义配置
+  description: '我的特殊设备'
+  icon: 'my_device.webp'
+  category: ['temperature', 'heating']
+```
+
+## 常见问题怎么排查
+
+### 设备加载不了
+
+1. 检查模块路径：确认 `class.module` 路径写对了
+2. 确认类能导入：看看你的 Python 驱动类能不能正常导入
+3. 检查语法：用 yaml 验证器看看文件格式对不对
+4. 查看日志：看 UniLabOS 启动时有没有报错信息
+
+### 自动生成失败了
+
+1. 类分析出问题：确认你的类继承了正确的基类
+2. 方法类型不明确：确保状态方法的返回类型写清楚了
+3. 导入有问题：检查类能不能被动态导入
+4. 没开完整注册：确认启用了 `complete_registry=True`
+
+### 前端显示有问题
+
+1. 重新生成：删掉旧的 yaml 文件，用编辑器重新生成
+2. 清除缓存：清除浏览器缓存，重新加载页面
+3. 检查字段：确认必需的字段（比如 `schema`）都有
+4. 验证数据：检查 `goal_default` 和 `schema` 的数据类型是不是一致
+
+### 动作执行出错
+
+1. 方法名不对：确认动作方法名符合规范（比如 `execute_<action_name>`）
+2. 参数映射错误：检查 `goal` 字段的参数映射是否正确
+3. 返回格式不对：确认方法返回值格式符合 `result` 映射
+4. 没异常处理：在驱动类里加上异常处理
+
+## 最佳实践
+
+### 开发流程
+
+1. **优先使用编辑器**：除非有特殊需求，否则优先使用注册表编辑器
+2. **最小化配置**：手动配置时只定义必要字段，让系统自动生成其他内容
+3. **增量开发**：先创建基本配置，后续根据需要添加特殊动作
+
+### 代码规范
+
+1. **方法命名**：状态方法使用 `get_` 前缀，动作方法使用动词开头
+2. **类型注解**：为方法参数和返回值添加类型注解
+3. **文档字符串**：为类和方法添加详细的文档字符串
+4. **异常处理**：实现完善的错误处理和日志记录
+
+### 配置管理
+
+1. **版本控制**：所有 yaml 文件纳入版本控制
+2. **命名一致性**：设备 ID、文件名、类名保持一致的命名风格
+3. **定期更新**：定期运行完整注册以更新自动生成的字段
+4. **备份配置**：在修改前备份重要的手动配置
+
+### 测试验证
+
+1. **本地测试**：在本地环境充分测试后再部署
+2. **渐进部署**：先部署到测试环境，验证无误后再上生产环境
+3. **监控日志**：密切监控设备加载和运行日志
+4. **回滚准备**：准备快速回滚机制，以应对紧急情况
+
+### 性能优化
+
+1. **按需加载**：只加载实际使用的设备类型
+2. **缓存利用**：充分利用系统的注册表缓存机制
+3. **资源管理**：合理管理设备连接和资源占用
+4. **监控指标**：设置关键性能指标的监控和告警

docs/developer_guide/workstation_architecture.md

@@ -0,0 +1,378 @@
+# 工作站基础架构设计文档
+
+## 1. 整体架构图
+
+```mermaid
+graph TB
+    subgraph "工作站基础架构"
+        WB[WorkstationBase]
+        WB --> |继承| RPN[ROS2WorkstationNode]
+        WB --> |组合| WCB[WorkstationCommunicationBase]
+        WB --> |组合| MMB[MaterialManagementBase]
+        WB --> |组合| WHS[WorkstationHTTPService]
+    end
+    
+    subgraph "通信层实现"
+        WCB --> |实现| PLC[PLCCommunication]
+        WCB --> |实现| SER[SerialCommunication]
+        WCB --> |实现| ETH[EthernetCommunication]
+    end
+    
+    subgraph "物料管理实现"
+        MMB --> |实现| PLR[PyLabRobotMaterialManager]
+        MMB --> |实现| BIO[BioyondMaterialManager]
+        MMB --> |实现| SIM[SimpleMaterialManager]
+    end
+    
+    subgraph "HTTP服务"
+        WHS --> |处理| LIMS[LIMS协议报送]
+        WHS --> |处理| MAT[物料变更报送]
+        WHS --> |处理| ERR[错误处理报送]
+    end
+    
+    subgraph "具体工作站实现"
+        WB --> |继承| WS1[PLCWorkstation]
+        WB --> |继承| WS2[ReportingWorkstation]
+        WB --> |继承| WS3[HybridWorkstation]
+    end
+    
+    subgraph "外部系统"
+        EXT1[PLC设备] --> |通信| PLC
+        EXT2[外部工作站] --> |HTTP报送| WHS
+        EXT3[LIMS系统] --> |HTTP报送| WHS
+        EXT4[Bioyond物料系统] --> |查询| BIO
+    end
+```
+
+## 2. 类关系图
+
+```mermaid
+classDiagram
+    class WorkstationBase {
+        <<abstract>>
+        +device_id: str
+        +communication: WorkstationCommunicationBase
+        +material_management: MaterialManagementBase
+        +http_service: WorkstationHTTPService
+        +workflow_status: WorkflowStatus
+        +supported_workflows: Dict
+        
+        +_create_communication_module()* 
+        +_create_material_management_module()*
+        +_register_supported_workflows()*
+        
+        +process_step_finish_report()
+        +process_sample_finish_report()
+        +process_order_finish_report()
+        +process_material_change_report()
+        +handle_external_error()
+        
+        +start_workflow()
+        +stop_workflow()
+        +get_workflow_status()
+        +get_device_status()
+    }
+    
+    class ROS2WorkstationNode {
+        +sub_devices: Dict
+        +protocol_names: List
+        +execute_single_action()
+        +create_ros_action_server()
+        +initialize_device()
+    }
+    
+    class WorkstationCommunicationBase {
+        <<abstract>>
+        +config: CommunicationConfig
+        +is_connected: bool
+        +connect()
+        +disconnect()
+        +start_workflow()*
+        +stop_workflow()*
+        +get_device_status()*
+        +write_register()
+        +read_register()
+    }
+    
+    class MaterialManagementBase {
+        <<abstract>>
+        +device_id: str
+        +deck_config: Dict
+        +resource_tracker: DeviceNodeResourceTracker
+        +plr_deck: Deck
+        +find_materials_by_type()
+        +update_material_location()
+        +convert_to_unilab_format()
+        +_create_resource_by_type()*
+    }
+    
+    class WorkstationHTTPService {
+        +workstation_instance: WorkstationBase
+        +host: str
+        +port: int
+        +start()
+        +stop()
+        +_handle_step_finish_report()
+        +_handle_material_change_report()
+    }
+    
+    class PLCWorkstation {
+        +plc_config: Dict
+        +modbus_client: ModbusTCPClient
+        +_create_communication_module()
+        +_create_material_management_module()
+        +_register_supported_workflows()
+    }
+    
+    class ReportingWorkstation {
+        +report_handlers: Dict
+        +_create_communication_module()
+        +_create_material_management_module()
+        +_register_supported_workflows()
+    }
+    
+    WorkstationBase --|> ROS2WorkstationNode
+    WorkstationBase *-- WorkstationCommunicationBase
+    WorkstationBase *-- MaterialManagementBase
+    WorkstationBase *-- WorkstationHTTPService
+    
+    PLCWorkstation --|> WorkstationBase
+    ReportingWorkstation --|> WorkstationBase
+    
+    WorkstationCommunicationBase <|-- PLCCommunication
+    WorkstationCommunicationBase <|-- DummyCommunication
+    
+    MaterialManagementBase <|-- PyLabRobotMaterialManager
+    MaterialManagementBase <|-- SimpleMaterialManager
+```
+
+## 3. 工作站启动时序图
+
+```mermaid
+sequenceDiagram
+    participant APP as Application
+    participant WS as WorkstationBase
+    participant COMM as CommunicationModule
+    participant MAT as MaterialManager
+    participant HTTP as HTTPService
+    participant ROS as ROS2WorkstationNode
+    
+    APP->>WS: 创建工作站实例
+    WS->>ROS: 初始化ROS2WorkstationNode
+    ROS->>ROS: 初始化子设备
+    ROS->>ROS: 设置硬件接口代理
+    
+    WS->>COMM: _create_communication_module()
+    COMM->>COMM: 初始化通信配置
+    COMM->>COMM: 建立PLC/串口连接
+    COMM-->>WS: 返回通信模块实例
+    
+    WS->>MAT: _create_material_management_module()
+    MAT->>MAT: 创建PyLabRobot Deck
+    MAT->>MAT: 初始化物料资源
+    MAT->>MAT: 注册到ResourceTracker
+    MAT-->>WS: 返回物料管理实例
+    
+    WS->>WS: _register_supported_workflows()
+    WS->>WS: _create_workstation_services()
+    WS->>HTTP: _start_http_service()
+    HTTP->>HTTP: 创建HTTP服务器
+    HTTP->>HTTP: 启动监听线程
+    HTTP-->>WS: HTTP服务启动完成
+    
+    WS-->>APP: 工作站初始化完成
+```
+
+## 4. 工作流执行时序图
+
+```mermaid
+sequenceDiagram
+    participant EXT as ExternalSystem
+    participant WS as WorkstationBase
+    participant COMM as CommunicationModule
+    participant MAT as MaterialManager
+    participant ROS as ROS2WorkstationNode
+    participant DEV as SubDevice
+    
+    EXT->>WS: start_workflow(type, params)
+    WS->>WS: 验证工作流类型
+    WS->>COMM: start_workflow(type, params)
+    COMM->>COMM: 发送启动命令到PLC
+    COMM-->>WS: 启动成功
+    
+    WS->>WS: 更新workflow_status = RUNNING
+    
+    loop 工作流步骤执行
+        WS->>ROS: execute_single_action(device_id, action, params)
+        ROS->>DEV: 发送ROS Action请求
+        DEV->>DEV: 执行设备动作
+        DEV-->>ROS: 返回执行结果
+        ROS-->>WS: 返回动作结果
+        
+        WS->>MAT: update_material_location(material_id, location)
+        MAT->>MAT: 更新PyLabRobot资源状态
+        MAT-->>WS: 更新完成
+    end
+    
+    WS->>COMM: get_workflow_status()
+    COMM->>COMM: 查询PLC状态寄存器
+    COMM-->>WS: 返回状态信息
+    
+    WS->>WS: 更新workflow_status = COMPLETED
+    WS-->>EXT: 工作流执行完成
+```
+
+## 5. HTTP报送处理时序图
+
+```mermaid
+sequenceDiagram
+    participant EXT as ExternalWorkstation
+    participant HTTP as HTTPService
+    participant WS as WorkstationBase
+    participant MAT as MaterialManager
+    participant DB as DataStorage
+    
+    EXT->>HTTP: POST /report/step_finish
+    HTTP->>HTTP: 解析请求数据
+    HTTP->>HTTP: 验证LIMS协议字段
+    HTTP->>WS: process_step_finish_report(request)
+    
+    WS->>WS: 增加接收计数
+    WS->>WS: 记录步骤完成事件
+    WS->>MAT: 更新相关物料状态
+    MAT->>MAT: 更新PyLabRobot资源
+    MAT-->>WS: 更新完成
+    
+    WS->>DB: 保存报送记录
+    DB-->>WS: 保存完成
+    
+    WS-->>HTTP: 返回处理结果
+    HTTP->>HTTP: 构造HTTP响应
+    HTTP-->>EXT: 200 OK + acknowledgment_id
+    
+    Note over EXT,DB: 类似处理sample_finish, order_finish, material_change等报送
+```
+
+## 6. 错误处理时序图
+
+```mermaid
+sequenceDiagram
+    participant DEV as Device
+    participant WS as WorkstationBase
+    participant COMM as CommunicationModule
+    participant HTTP as HTTPService
+    participant EXT as ExternalSystem
+    
+    DEV->>WS: 设备错误事件
+    WS->>WS: handle_external_error(error_data)
+    WS->>WS: 记录错误历史
+    
+    alt 关键错误
+        WS->>COMM: emergency_stop()
+        COMM->>COMM: 发送紧急停止命令
+        WS->>WS: 更新workflow_status = ERROR
+    else 普通错误
+        WS->>WS: 标记动作失败
+        WS->>WS: 触发重试逻辑
+    end
+    
+    WS->>HTTP: 记录错误报送
+    HTTP->>EXT: 主动通知错误状态
+    
+    WS-->>DEV: 错误处理完成
+```
+
+## 7. 典型工作站实现示例
+
+### 7.1 PLC工作站实现
+
+```python
+class PLCWorkstation(WorkstationBase):
+    def _create_communication_module(self):
+        return PLCCommunication(self.communication_config)
+    
+    def _create_material_management_module(self):
+        return PyLabRobotMaterialManager(
+            self.device_id, 
+            self.deck_config, 
+            self.resource_tracker
+        )
+    
+    def _register_supported_workflows(self):
+        self.supported_workflows = {
+            "battery_assembly": WorkflowInfo(...),
+            "quality_check": WorkflowInfo(...)
+        }
+```
+
+### 7.2 报送接收工作站实现
+
+```python
+class ReportingWorkstation(WorkstationBase):
+    def _create_communication_module(self):
+        return DummyCommunication(self.communication_config)
+    
+    def _create_material_management_module(self):
+        return SimpleMaterialManager(
+            self.device_id,
+            self.deck_config,
+            self.resource_tracker
+        )
+    
+    def _register_supported_workflows(self):
+        self.supported_workflows = {
+            "data_collection": WorkflowInfo(...),
+            "report_processing": WorkflowInfo(...)
+        }
+```
+
+## 8. 核心接口说明
+
+### 8.1 必须实现的抽象方法
+- `_create_communication_module()`: 创建通信模块
+- `_create_material_management_module()`: 创建物料管理模块
+- `_register_supported_workflows()`: 注册支持的工作流
+
+### 8.2 可重写的报送处理方法
+- `process_step_finish_report()`: 步骤完成处理
+- `process_sample_finish_report()`: 样本完成处理
+- `process_order_finish_report()`: 订单完成处理
+- `process_material_change_report()`: 物料变更处理
+- `handle_external_error()`: 错误处理
+
+### 8.3 工作流控制接口
+- `start_workflow()`: 启动工作流
+- `stop_workflow()`: 停止工作流
+- `get_workflow_status()`: 获取状态
+
+## 9. 配置参数说明
+
+```python
+workstation_config = {
+    "communication_config": {
+        "protocol": "modbus_tcp",
+        "host": "192.168.1.100",
+        "port": 502
+    },
+    "deck_config": {
+        "size_x": 1000.0,
+        "size_y": 1000.0,
+        "size_z": 500.0
+    },
+    "http_service_config": {
+        "enabled": True,
+        "host": "127.0.0.1",
+        "port": 8081
+    },
+    "communication_interfaces": {
+        "logical_device_1": CommunicationInterface(...)
+    }
+}
+```
+
+这个架构设计支持：
+1. **灵活的通信方式**: 通过CommunicationBase支持PLC、串口、以太网等
+2. **多样的物料管理**: 支持PyLabRobot、Bioyond、简单物料系统
+3. **统一的HTTP报送**: 基于LIMS协议的标准化报送接口
+4. **完整的工作流控制**: 支持动态和静态工作流
+5. **强大的错误处理**: 多层次的错误处理和恢复机制

docs/user_guide/configuration.md

@@ -1,82 +1,73 @@
 # Uni-Lab 配置指南
 
-Uni-Lab支持通过Python配置文件进行灵活的系统配置。本指南将帮助您理解配置选项并设置您的Uni-Lab环境。
+Uni-Lab 支持通过 Python 配置文件进行灵活的系统配置。本指南将帮助您理解配置选项并设置您的 Uni-Lab 环境。
 
 ## 配置文件格式
 
-Uni-Lab支持Python格式的配置文件，它比YAML或JSON提供更多的灵活性，包括支持注释、条件逻辑和复杂数据结构。
+Uni-Lab 支持 Python 格式的配置文件，它比 YAML 或 JSON 提供更多的灵活性，包括支持注释、条件逻辑和复杂数据结构。
 
-### 基本配置示例
+### 默认配置示例
 
-一个典型的配置文件包含以下部分：
+首次使用时，系统会自动创建一个基础配置文件 `local_config.py`：
+
+```python
+# unilabos的配置文件
+
+class BasicConfig:
+    ak = ""  # 实验室网页给您提供的ak代码，您可以在配置文件中指定，也可以通过运行unilabos时以 --ak 传入，优先按照传入参数解析
+    sk = ""  # 实验室网页给您提供的sk代码，您可以在配置文件中指定，也可以通过运行unilabos时以 --sk 传入，优先按照传入参数解析
+
+
+# WebSocket配置，一般无需调整
+class WSConfig:
+    reconnect_interval = 5  # 重连间隔（秒）
+    max_reconnect_attempts = 999  # 最大重连次数
+    ping_interval = 30  # ping间隔（秒）
+```
+
+### 完整配置示例
+
+您可以根据需要添加更多配置选项：
 
 ```python
 #!/usr/bin/env python
 # coding=utf-8
 """Uni-Lab 配置文件"""
 
-from dataclasses import dataclass
+# 基础配置
+class BasicConfig:
+    ak = "your_access_key"  # 实验室访问密钥
+    sk = "your_secret_key"  # 实验室私钥
+    working_dir = ""  # 工作目录（通常自动设置）
+    config_path = ""  # 配置文件路径（自动设置）
+    is_host_mode = True  # 是否为主站模式
+    slave_no_host = False  # 从站模式下是否跳过等待主机服务
+    upload_registry = False  # 是否上传注册表
+    machine_name = "undefined"  # 机器名称（自动获取）
+    vis_2d_enable = False  # 是否启用2D可视化
+    enable_resource_load = True  # 是否启用资源加载
+    communication_protocol = "websocket"  # 通信协议
 
-# 配置类定义
+# WebSocket配置
+class WSConfig:
+    reconnect_interval = 5  # 重连间隔（秒）
+    max_reconnect_attempts = 999  # 最大重连次数
+    ping_interval = 30  # ping间隔（秒）
 
-class MQConfig:
-    """MQTT 配置类"""
-    lab_id: str = "YOUR_LAB_ID"
-    # 更多配置...
+# OSS上传配置
+class OSSUploadConfig:
+    api_host = ""  # API主机地址
+    authorization = ""  # 授权信息
+    init_endpoint = ""  # 初始化端点
+    complete_endpoint = ""  # 完成端点
+    max_retries = 3  # 最大重试次数
 
-# 其他配置类...
-```
-
-## 配置选项说明
-
-### MQTT配置 (MQConfig)
-
-MQTT配置用于连接消息队列服务，是Uni-Lab与云端通信的主要方式。
-
-```python
-
-class MQConfig:
-    """MQTT 配置类"""
-    lab_id: str = "7AAEDBEA"  # 实验室唯一标识
-    instance_id: str = "mqtt-cn-instance"
-    access_key: str = "your-access-key"
-    secret_key: str = "your-secret-key"
-    group_id: str = "GID_labs"
-    broker_url: str = "mqtt-cn-instance.mqtt.aliyuncs.com"
-    port: int = 8883
-    
-    # 可以直接提供证书文件路径
-    ca_file: str = "/path/to/ca.pem"  # 相对config.py所在目录的路径
-    cert_file: str = "/path/to/cert.pem"  # 相对config.py所在目录的路径
-    key_file: str = "/path/to/key.pem"  # 相对config.py所在目录的路径
-    
-    # 或者直接提供证书内容
-    ca_content: str = ""
-    cert_content: str = ""
-    key_content: str = ""
-```
-
-#### 证书配置
-
-MQTT连接支持两种方式配置证书：
-
-1. **文件路径方式**（推荐）：指定证书文件的路径，系统会自动读取文件内容
-2. **直接内容方式**：直接在配置中提供证书内容
-
-推荐使用文件路径方式，便于证书的更新和管理。
-
-### HTTP客户端配置 (HTTPConfig)
-
-即将开放 Uni-Lab 云端实验室。
-
-### ROS模块配置 (ROSConfig)
-
-配置ROS消息转换器需要加载的模块：
-
-```python
+# HTTP配置
+class HTTPConfig:
+    remote_addr = "http://127.0.0.1:48197/api/v1"  # 远程地址
 
+# ROS配置
 class ROSConfig:
-    """ROS模块配置"""
     modules = [
         "std_msgs.msg",
         "geometry_msgs.msg",
@@ -85,25 +76,365 @@ class ROSConfig:
         "nav2_msgs.action",
         "unilabos_msgs.msg",
         "unilabos_msgs.action",
+    ]  # 需要加载的ROS模块
+```
+
+## 命令行参数覆盖配置
+
+Uni-Lab 允许通过命令行参数覆盖配置文件中的设置，提供更灵活的配置方式。命令行参数的优先级高于配置文件。
+
+### 支持命令行覆盖的配置项
+
+以下配置项可以通过命令行参数进行覆盖：
+
+| 配置类        | 配置字段          | 命令行参数          | 说明                             |
+| ------------- | ----------------- | ------------------- | -------------------------------- |
+| `BasicConfig` | `ak`              | `--ak`              | 实验室访问密钥                   |
+| `BasicConfig` | `sk`              | `--sk`              | 实验室私钥                       |
+| `BasicConfig` | `working_dir`     | `--working_dir`     | 工作目录路径                     |
+| `BasicConfig` | `is_host_mode`    | `--is_slave`        | 主站模式（参数为从站模式，取反） |
+| `BasicConfig` | `slave_no_host`   | `--slave_no_host`   | 从站模式下跳过等待主机服务       |
+| `BasicConfig` | `upload_registry` | `--upload_registry` | 启动时上传注册表信息             |
+| `BasicConfig` | `vis_2d_enable`   | `--2d_vis`          | 启用 2D 可视化                   |
+| `HTTPConfig`  | `remote_addr`     | `--addr`            | 远程服务地址                     |
+
+### 特殊命令行参数
+
+除了直接覆盖配置项的参数外，还有一些特殊的命令行参数：
+
+| 参数                | 说明                                 |
+| ------------------- | ------------------------------------ |
+| `--config`          | 指定配置文件路径                     |
+| `--port`            | Web 服务端口（不影响配置文件）       |
+| `--disable_browser` | 禁用自动打开浏览器（不影响配置文件） |
+| `--visual`          | 可视化工具选择（不影响配置文件）     |
+| `--skip_env_check`  | 跳过环境检查（不影响配置文件）       |
+
+### 配置优先级
+
+配置项的生效优先级从高到低为：
+
+1. **命令行参数**：最高优先级
+2. **环境变量**：中等优先级
+3. **配置文件**：基础优先级
+
+### 使用示例
+
+```bash
+# 通过命令行覆盖认证信息
+unilab --ak "new_access_key" --sk "new_secret_key"
+
+# 覆盖服务器地址
+unilab --addr "https://custom.server.com/api/v1"
+
+# 启用从站模式并跳过等待主机
+unilab --is_slave --slave_no_host
+
+# 启用上传注册表和2D可视化
+unilab --upload_registry --2d_vis
+
+# 组合使用多个覆盖参数
+unilab --ak "key" --sk "secret" --addr "test" --upload_registry --2d_vis
+```
+
+### 预设环境地址
+
+`--addr` 参数支持以下预设值，会自动转换为对应的完整 URL：
+
+- `test` → `https://uni-lab.test.bohrium.com/api/v1`
+- `uat` → `https://uni-lab.uat.bohrium.com/api/v1`
+- `local` → `http://127.0.0.1:48197/api/v1`
+- 其他值 → 直接使用作为完整 URL
+
+## 配置选项详解
+
+### 基础配置 (BasicConfig)
+
+基础配置包含了系统运行的核心参数：
+
+| 参数                     | 类型 | 默认值        | 说明                                       |
+| ------------------------ | ---- | ------------- | ------------------------------------------ |
+| `ak`                     | str  | `""`          | 实验室访问密钥（必需）                     |
+| `sk`                     | str  | `""`          | 实验室私钥（必需）                         |
+| `working_dir`            | str  | `""`          | 工作目录，通常自动设置                     |
+| `is_host_mode`           | bool | `True`        | 是否为主站模式                             |
+| `slave_no_host`          | bool | `False`       | 从站模式下是否跳过等待主机服务             |
+| `upload_registry`        | bool | `False`       | 启动时是否上传注册表信息                   |
+| `machine_name`           | str  | `"undefined"` | 机器名称，自动从 hostname 获取（不可配置） |
+| `vis_2d_enable`          | bool | `False`       | 是否启用 2D 可视化                         |
+| `communication_protocol` | str  | `"websocket"` | 通信协议，固定为 websocket                 |
+
+#### 认证配置
+
+`ak` 和 `sk` 是必需的认证参数：
+
+1. **获取方式**：在 [Uni-Lab 官网](https://uni-lab.bohrium.com) 注册实验室后获得
+2. **配置方式**：
+   - **命令行参数**：`--ak "your_key" --sk "your_secret"`（最高优先级）
+   - **配置文件**：在 `BasicConfig` 类中设置
+   - **环境变量**：`UNILABOS_BASICCONFIG_AK` 和 `UNILABOS_BASICCONFIG_SK`
+3. **优先级顺序**：命令行参数 > 环境变量 > 配置文件
+4. **安全注意**：请妥善保管您的密钥信息
+
+**推荐做法**：
+
+- 开发环境：使用配置文件
+- 生产环境：使用环境变量或命令行参数
+- 临时测试：使用命令行参数
+
+### WebSocket 配置 (WSConfig)
+
+WebSocket 是 Uni-Lab 的主要通信方式：
+
+| 参数                     | 类型 | 默认值 | 说明               |
+| ------------------------ | ---- | ------ | ------------------ |
+| `reconnect_interval`     | int  | `5`    | 断线重连间隔（秒） |
+| `max_reconnect_attempts` | int  | `999`  | 最大重连次数       |
+| `ping_interval`          | int  | `30`   | 心跳检测间隔（秒） |
+
+### HTTP 配置 (HTTPConfig)
+
+HTTP 客户端配置用于与云端服务通信：
+
+| 参数          | 类型 | 默认值                            | 说明         |
+| ------------- | ---- | --------------------------------- | ------------ |
+| `remote_addr` | str  | `"http://127.0.0.1:48197/api/v1"` | 远程服务地址 |
+
+**预设环境地址**：
+
+- 生产环境：`https://uni-lab.bohrium.com/api/v1`
+- 测试环境：`https://uni-lab.test.bohrium.com/api/v1`
+- UAT 环境：`https://uni-lab.uat.bohrium.com/api/v1`
+- 本地环境：`http://127.0.0.1:48197/api/v1`
+
+### ROS 配置 (ROSConfig)
+
+配置 ROS 消息转换器需要加载的模块：
+
+```python
+class ROSConfig:
+    modules = [
+        "std_msgs.msg",           # 标准消息类型
+        "geometry_msgs.msg",      # 几何消息类型
+        "control_msgs.msg",       # 控制消息类型
+        "control_msgs.action",    # 控制动作类型
+        "nav2_msgs.action",       # 导航动作类型
+        "unilabos_msgs.msg",      # UniLab 自定义消息类型
+        "unilabos_msgs.action",   # UniLab 自定义动作类型
     ]
 ```
 
-您可以根据需要添加其他ROS模块。
+您可以根据实际使用的设备和功能添加其他 ROS 模块。
 
-### 其他配置选项
+### OSS 上传配置 (OSSUploadConfig)
 
-- **OSSUploadConfig**: 对象存储上传配置
+对象存储服务配置，用于文件上传功能：
 
-## 如何使用配置文件
+| 参数                | 类型 | 默认值 | 说明                 |
+| ------------------- | ---- | ------ | -------------------- |
+| `api_host`          | str  | `""`   | OSS API 主机地址     |
+| `authorization`     | str  | `""`   | 授权认证信息         |
+| `init_endpoint`     | str  | `""`   | 上传初始化端点       |
+| `complete_endpoint` | str  | `""`   | 上传完成端点         |
+| `max_retries`       | int  | `3`    | 上传失败最大重试次数 |
 
-启动Uni-Lab时通过`--config`参数指定配置文件路径：
+## 环境变量支持
+
+Uni-Lab 支持通过环境变量覆盖配置文件中的设置。环境变量格式为：
+
+```
+UNILABOS_{配置类名}_{字段名}
+```
+
+### 环境变量示例
 
 ```bash
-unilab --config path/to/your/config.py
+# 设置基础配置
+export UNILABOS_BASICCONFIG_AK="your_access_key"
+export UNILABOS_BASICCONFIG_SK="your_secret_key"
+export UNILABOS_BASICCONFIG_IS_HOST_MODE="true"
+
+# 设置WebSocket配置
+export UNILABOS_WSCONFIG_RECONNECT_INTERVAL="10"
+export UNILABOS_WSCONFIG_MAX_RECONNECT_ATTEMPTS="500"
+
+# 设置HTTP配置
+export UNILABOS_HTTPCONFIG_REMOTE_ADDR="https://uni-lab.bohrium.com/api/v1"
 ```
 
-如果您不涉及多环境开发，可以在unilabos的安装路径中手动添加local_config.py的文件
+### 环境变量类型转换
 
-# 启动Uni-Lab
-python -m unilabos.app.main --config path/to/your/config.py
+- **布尔值**：`"true"`, `"1"`, `"yes"` → `True`；其他 → `False`
+- **整数**：自动转换为 `int` 类型
+- **浮点数**：自动转换为 `float` 类型
+- **字符串**：保持原值
+
+## 配置文件使用方法
+
+### 1. 指定配置文件启动
+
+```bash
+# 使用指定配置文件启动
+unilab --config /path/to/your/config.py
 ```
+
+### 2. 使用默认配置文件
+
+如果不指定配置文件，系统会按以下顺序查找：
+
+1. 环境变量 `UNILABOS_BASICCONFIG_CONFIG_PATH` 指定的路径
+2. 工作目录下的 `local_config.py`
+3. 首次使用时会引导创建配置文件
+
+### 3. 配置文件验证
+
+系统启动时会自动验证配置文件：
+
+- **语法检查**：确保 Python 语法正确
+- **类型检查**：验证配置项类型是否匹配
+- **必需项检查**：确保 `ak` 和 `sk` 已配置
+
+## 最佳实践
+
+### 1. 安全配置
+
+- 不要将包含密钥的配置文件提交到版本控制系统
+- 使用环境变量或命令行参数在生产环境中配置敏感信息
+- 定期更换访问密钥
+- **推荐配置方式**：
+
+  ```bash
+  # 生产环境 - 使用环境变量
+  export UNILABOS_BASICCONFIG_AK="your_access_key"
+  export UNILABOS_BASICCONFIG_SK="your_secret_key"
+  unilab
+
+  # 或使用命令行参数
+  unilab --ak "your_access_key" --sk "your_secret_key"
+  ```
+
+### 2. 多环境配置
+
+为不同环境创建不同的配置文件并结合命令行参数：
+
+```
+configs/
+├── local_config.py      # 本地开发
+├── test_config.py       # 测试环境
+├── prod_config.py       # 生产环境
+└── example_config.py    # 示例配置
+```
+
+**环境切换示例**：
+
+```bash
+# 本地开发环境
+unilab --config configs/local_config.py --addr local
+
+# 测试环境
+unilab --config configs/test_config.py --addr test --upload_registry
+
+# 生产环境
+unilab --config configs/prod_config.py --ak "$PROD_AK" --sk "$PROD_SK"
+```
+
+### 3. 配置管理
+
+- 保持配置文件简洁，只包含需要修改的配置项
+- 为配置项添加注释说明其作用
+- 定期检查和更新配置文件
+- **命令行参数优先使用场景**：
+  - 临时测试不同配置
+  - CI/CD 流水线中的动态配置
+  - 不同环境间快速切换
+  - 敏感信息的安全传递
+
+### 4. 灵活配置策略
+
+**基础配置文件 + 命令行覆盖**的推荐方式：
+
+```python
+# base_config.py - 基础配置
+class BasicConfig:
+    # 非敏感配置写在文件中
+    is_host_mode = True
+    upload_registry = False
+    vis_2d_enable = False
+
+class WSConfig:
+    reconnect_interval = 5
+    max_reconnect_attempts = 999
+    ping_interval = 30
+```
+
+```bash
+# 启动时通过命令行覆盖关键参数
+unilab --config base_config.py \
+       --ak "$AK" \
+       --sk "$SK" \
+       --addr "test" \
+       --upload_registry \
+       --2d_vis
+```
+
+## 故障排除
+
+### 1. 配置文件加载失败
+
+**错误信息**：`[ENV] 配置文件 xxx 不存在`
+
+**解决方法**：
+
+- 确认配置文件路径正确
+- 检查文件权限是否可读
+- 确保配置文件是 `.py` 格式
+
+### 2. 语法错误
+
+**错误信息**：`[ENV] 加载配置文件 xxx 失败`
+
+**解决方法**：
+
+- 检查 Python 语法是否正确
+- 确认类名和字段名拼写正确
+- 验证缩进是否正确（使用空格而非制表符）
+
+### 3. 认证失败
+
+**错误信息**：`后续运行必须拥有一个实验室`
+
+**解决方法**：
+
+- 确认 `ak` 和 `sk` 已正确配置
+- 检查密钥是否有效
+- 确认网络连接正常
+
+### 4. 环境变量不生效
+
+**解决方法**：
+
+- 确认环境变量名格式正确（`UNILABOS_CLASS_FIELD`）
+- 检查环境变量是否已正确设置
+- 重启系统或重新加载环境变量
+
+### 5. 命令行参数不生效
+
+**错误现象**：设置了命令行参数但配置没有生效
+
+**解决方法**：
+
+- 确认参数名拼写正确（如 `--ak` 而不是 `--access_key`）
+- 检查参数格式是否正确（布尔参数如 `--is_slave` 不需要值）
+- 确认参数位置正确（所有参数都应在 `unilab` 之后）
+- 查看启动日志确认参数是否被正确解析
+
+### 6. 配置优先级混淆
+
+**错误现象**：不确定哪个配置生效
+
+**解决方法**：
+
+- 记住优先级：命令行参数 > 环境变量 > 配置文件
+- 使用 `--ak` 和 `--sk` 参数时会看到提示信息
+- 检查启动日志中的配置加载信息
+- 临时移除低优先级配置来测试高优先级配置是否生效

docs/user_guide/installation.md

@@ -1,24 +1,43 @@
 # **Uni-Lab 安装**
 
-请先 `git clone` 本仓库，随后按照以下步骤安装项目：
+## 快速开始
 
-`Uni-Lab` 建议您采用 `mamba` 管理环境。若需从头建立 `Uni-Lab` 的运行依赖环境，请执行
+1. **配置 Conda 环境**
+
+Uni-Lab-OS 建议使用 `mamba` 管理环境。创建新的环境：
 
 ```shell
-mamba env create -f unilabos-<YOUR_OS>.yaml
-mamba activate unilab
+mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
-其中 `YOUR_OS` 是您的操作系统，可选值 `win64`, `linux-64`, `osx-64`, `osx-arm64`
-
-若需将依赖安装进当前环境，请执行
+2. **安装开发版 Uni-Lab-OS**
 
 ```shell
-conda env update --file unilabos-<YOUR_OS>.yml
+# 配置好conda环境后，克隆仓库
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git -b dev
+cd Uni-Lab-OS
+
+# 安装 Uni-Lab-OS
+pip install -e .
 ```
 
-随后，可在本仓库安装 `unilabos` 的开发版：
+3. **安装开发版 ros-humble-unilabos-msgs**
 
+**卸载老版本：**
 ```shell
-pip install .
+conda activate unilab
+conda remove --force ros-humble-unilabos-msgs
 ```
+有时相同的安装包版本会由于dev构建得到的md5不一样，触发安全检查，可输入 `config set safety_checks disabled` 来关闭安全检查。
+
+**安装新版本：**
+
+访问 https://github.com/dptech-corp/Uni-Lab-OS/actions/workflows/multi-platform-build.yml 选择最新的构建，下载对应平台的压缩包（仅解压一次，得到.conda文件）使用如下指令：
+```shell
+conda activate base
+conda install ros-humble-unilabos-msgs-<version>-<platform>.conda --offline -n <环境名>
+```
+
+4. **启动 Uni-Lab 系统**
+
+请参见{doc}`启动样例 <../boot_examples/index>`或{doc}`启动指南 <launch>`了解详细的启动方法。

docs/user_guide/launch.md

@@ -1,4 +1,4 @@
-# Uni-Lab 启动
+# Uni-Lab 启动指南
 
 安装完毕后，可以通过 `unilab` 命令行启动：
 
@@ -8,70 +8,240 @@ Start Uni-Lab Edge server.
 options:
   -h, --help            show this help message and exit
   -g GRAPH, --graph GRAPH
-                        Physical setup graph.
-  -d DEVICES, --devices DEVICES
-                        Devices config file.
-  -r RESOURCES, --resources RESOURCES
-                        Resources config file.
+                        Physical setup graph file path.
   -c CONTROLLERS, --controllers CONTROLLERS
-                        Controllers config file.
+                        Controllers config file path.
   --registry_path REGISTRY_PATH
-                        Path to the registry
+                        Path to the registry directory
+  --working_dir WORKING_DIR
+                        Path to the working directory
   --backend {ros,simple,automancer}
                         Choose the backend to run with: 'ros', 'simple', or 'automancer'.
   --app_bridges APP_BRIDGES [APP_BRIDGES ...]
-                        Bridges to connect to. Now support 'mqtt' and 'fastapi'.
-  --without_host        Run the backend as slave (without host).
-  --config CONFIG       Configuration file path for system settings
+                        Bridges to connect to. Now support 'websocket' and 'fastapi'.
+  --is_slave            Run the backend as slave node (without host privileges).
+  --slave_no_host       Skip waiting for host service in slave mode
+  --upload_registry     Upload registry information when starting unilab
+  --use_remote_resource Use remote resources when starting unilab
+  --config CONFIG       Configuration file path, supports .py format Python config files
+  --port PORT           Port for web service information page
+  --disable_browser     Disable opening information page on startup
+  --2d_vis              Enable 2D visualization when starting pylabrobot instance
+  --visual {rviz,web,disable}
+                        Choose visualization tool: rviz, web, or disable
+  --ak AK               Access key for laboratory requests
+  --sk SK               Secret key for laboratory requests
+  --addr ADDR           Laboratory backend address
+  --skip_env_check      Skip environment dependency check on startup
+  --complete_registry   Complete registry information
 ```
 
+## 启动流程详解
+
+Uni-Lab 的启动过程分为以下几个阶段：
+
+### 1. 参数解析阶段
+
+- 解析命令行参数
+- 处理参数格式转换（支持 dash 和 underscore 格式）
+
+### 2. 环境检查阶段 (可选)
+
+- 默认进行环境依赖检查并自动安装必需包
+- 使用 `--skip_env_check` 可跳过此步骤
+
+### 3. 配置文件处理阶段
+
+您可以直接跟随 unilabos 的提示进行，无需查阅本节
+
+- **工作目录设置**：
+
+  - 如果当前目录以 `unilabos_data` 结尾，则使用当前目录
+  - 否则使用 `当前目录/unilabos_data` 作为工作目录
+  - 可通过 `--working_dir` 指定自定义工作目录
+
+- **配置文件查找顺序**：
+  1. 使用 `--config` 参数指定的配置文件
+  2. 在工作目录中查找 `local_config.py`
+  3. 首次使用时会引导创建配置文件
+
+### 4. 服务器地址配置
+
+支持多种后端环境：
+
+- `--addr test`：测试环境 (`https://uni-lab.test.bohrium.com/api/v1`)
+- `--addr uat`：UAT 环境 (`https://uni-lab.uat.bohrium.com/api/v1`)
+- `--addr local`：本地环境 (`http://127.0.0.1:48197/api/v1`)
+- 自定义地址：直接指定完整 URL
+
+### 5. 认证配置
+
+- **必需参数**：`--ak` 和 `--sk` 必须同时提供
+- 命令行参数优先于配置文件中的设置
+- 未提供认证信息会导致启动失败并提示注册实验室
+
+### 6. 设备图谱加载
+
+支持两种方式：
+
+- **本地文件**：使用 `-g` 指定图谱文件（支持 JSON 和 GraphML 格式）
+- **远程资源**：使用 `--use_remote_resource` 从云端获取
+
+### 7. 注册表构建
+
+- 构建设备和资源注册表
+- 支持自定义注册表路径 (`--registry_path`)
+- 可选择补全注册表信息 (`--complete_registry`)
+
+### 8. 设备验证和注册
+
+- 验证设备连接和端点配置
+- 自动注册设备到云端服务
+
+### 9. 通信桥接配置
+
+- **WebSocket**：实时通信和任务下发
+- **FastAPI**：HTTP API 服务和物料更新
+
+### 10. 可视化和服务启动
+
+- 可选启动可视化工具 (`--visual`)
+- 启动 Web 信息服务 (默认端口 8002)
+- 启动后端通信服务
+
 ## 使用配置文件
 
-Uni-Lab支持使用Python格式的配置文件进行系统设置。通过 `--config` 参数指定配置文件路径：
+Uni-Lab 支持使用 Python 格式的配置文件进行系统设置。通过 `--config` 参数指定配置文件路径：
 
 ```bash
 # 使用配置文件启动
 unilab --config path/to/your/config.py
 ```
 
-配置文件包含MQTT、HTTP、ROS等系统设置。有关配置文件的详细信息，请参阅[配置指南](configuration.md)。
+配置文件包含实验室和 WebSocket 连接等设置。有关配置文件的详细信息，请参阅[配置指南](configuration.md)。
 
 ## 初始化信息来源
 
-启动 Uni-Lab 时，可以选用两种方式之一配置实验室设备、耗材、通信、控制逻辑：
+启动 Uni-Lab 时，可以选用两种方式之一配置实验室设备：
 
 ### 1. 组态&拓扑图
 
-使用 `-g` 时，组态&拓扑图应包含实验室所有信息，详见{ref}`graph`。目前支持 graphml 和 node-link json 两种格式。格式可参照 `tests/experiments` 下的启动文件。
+使用 `-g` 时，组态&拓扑图应包含实验室所有信息，详见{ref}`graph`。目前支持 GraphML 和 node-link JSON 两种格式。格式可参照 `tests/experiments` 下的启动文件。
 
-### 2. 分别指定设备、耗材、控制逻辑
+### 2. 分别指定控制逻辑
 
-分别使用 `-d, -r, -c` 依次传入设备组态配置、耗材列表、控制逻辑。
+使用 `-c` 传入控制逻辑配置。
 
-可参照 `devices.json` 和 `resources.json`。
-
-不管使用哪一种初始化方式，设备/物料字典均需包含 `class` 属性，用于查找注册表信息。默认查找范围都是 Uni-Lab 内部注册表 `unilabos/registry/{devices,device_comms,resources}`。要添加额外的注册表路径，可以使用 `--registry` 加入 `<your-registry-path>/{devices,device_comms,resources}`。
+不管使用哪一种初始化方式，设备/物料字典均需包含 `class` 属性，用于查找注册表信息。默认查找范围都是 Uni-Lab 内部注册表 `unilabos/registry/{devices,device_comms,resources}`。要添加额外的注册表路径，可以使用 `--registry_path` 加入 `<your-registry-path>/{devices,device_comms,resources}`。
 
 ## 通信中间件 `--backend`
 
-目前 Uni-Lab 仅支持 ros2 作为通信中间件。
+目前 Uni-Lab 支持以下通信中间件：
+
+- **ros** (默认)：基于 ROS2 的通信
+- **simple**：简化通信模式
+- **automancer**：Automancer 兼容模式
 
 ## 端云桥接 `--app_bridges`
 
-目前 Uni-Lab 提供 FastAPI (http), MQTT 两种端云通信方式。其中默认 MQTT 负责端对云状态同步和云对端任务下发，FastAPI 负责端对云物料更新。
+目前 Uni-Lab 提供 WebSocket、FastAPI (http) 两种端云通信方式：
+
+- **WebSocket**：负责实时通信和任务下发
+- **FastAPI**：负责端对云物料更新和 HTTP API
 
 ## 分布式组网
 
-启动 Uni-Lab 时，加入 `--without_host` 将作为从站，不加将作为主站，主站 (host) 持有物料修改权以及对云端的通信。局域网内分别启动的 Uni-Lab 主站/从站将自动组网，互相能访问所有设备状态、传感器信息并发送指令。
+启动 Uni-Lab 时，加入 `--is_slave` 将作为从站，不加将作为主站：
+
+- **主站 (host)**：持有物料修改权以及对云端的通信
+- **从站 (slave)**：无主机权限，可选择跳过等待主机服务 (`--slave_no_host`)
+
+局域网内分别启动的 Uni-Lab 主站/从站将自动组网，互相能访问所有设备状态、传感器信息并发送指令。
+
+## 可视化选项
+
+### 2D 可视化
+
+使用 `--2d_vis` 在 PyLabRobot 实例启动时同时启动 2D 可视化。
+
+### 3D 可视化
+
+通过 `--visual` 参数选择：
+
+- **rviz**：使用 RViz 进行 3D 可视化
+- **web**：使用 Web 界面进行可视化
+- **disable** (默认)：禁用可视化
+
+## 实验室管理
+
+### 首次使用
+
+如果是首次使用，系统会：
+
+1. 提示前往 https://uni-lab.bohrium.com 注册实验室
+2. 引导创建配置文件
+3. 设置工作目录
+
+### 认证设置
+
+- `--ak`：实验室访问密钥
+- `--sk`：实验室私钥
+- 两者必须同时提供才能正常启动
 
 ## 完整启动示例
 
 以下是一些常用的启动命令示例：
 
 ```bash
-# 使用配置文件和组态图启动
-unilab -g path/to/graph.json
+# 使用组态图启动，上传注册表
+unilab --ak your_ak --sk your_sk -g path/to/graph.json --upload_registry
 
-# 使用配置文件和分离的设备/资源文件启动
-unilab -d devices.json -r resources.json
+# 使用远程资源启动
+unilab --ak your_ak --sk your_sk --use_remote_resource
+
+# 更新注册表
+unilab --ak your_ak --sk your_sk --complete_registry
+
+# 启动从站模式
+unilab --ak your_ak --sk your_sk --is_slave
+
+# 启用可视化
+unilab --ak your_ak --sk your_sk --visual web --2d_vis
+
+# 指定本地信息网页服务端口和禁用自动跳出浏览器
+unilab --ak your_ak --sk your_sk --port 8080 --disable_browser
 ```
+
+## 常见问题
+
+### 1. 认证失败
+
+如果提示 "后续运行必须拥有一个实验室"，请确保：
+
+- 已在 https://uni-lab.bohrium.com 注册实验室
+- 正确设置了 `--ak` 和 `--sk` 参数
+- 配置文件中包含正确的认证信息
+
+### 2. 配置文件问题
+
+如果配置文件加载失败：
+
+- 确保配置文件是 `.py` 格式
+- 检查配置文件语法是否正确
+- 首次使用可让系统自动创建示例配置文件
+
+### 3. 网络连接问题
+
+如果无法连接到服务器：
+
+- 检查网络连接
+- 确认服务器地址是否正确
+- 尝试使用不同的环境地址（test、uat、local）
+
+### 4. 设备图谱问题
+
+如果设备加载失败：
+
+- 检查图谱文件格式是否正确
+- 验证设备连接和端点配置
+- 确保注册表路径正确

recipes/conda_build_config.yaml

@@ -1,3 +1,6 @@
+channel_sources:
+  - robostack,robostack-staging,conda-forge,defaults
+  
 gazebo:
   - '11'
 libpqxx:

recipes/msgs/bld_ament_cmake.bat

@@ -1,6 +1,7 @@
 :: Generated by vinca http://github.com/RoboStack/vinca.
 :: DO NOT EDIT!
-setlocal EnableDelayedExpansion
+@echo off
+setlocal enabledelayedexpansion
 
 set "PYTHONPATH=%LIBRARY_PREFIX%\lib\site-packages;%SP_DIR%"
 
@@ -16,9 +17,11 @@ pushd build
 
 :: try to fix long paths issues by using default generator
 set "CMAKE_GENERATOR=Visual Studio %VS_MAJOR% %VS_YEAR%"
-set "SP_DIR_FORWARDSLASHES=%SP_DIR:\=/%"
 
 set PYTHON="%PREFIX%\python.exe"
+set PYTHON=%PYTHON:\=/%
+set SP_DIR="..\Lib\site-packages"
+set SP_DIR=%SP_DIR:\=/%
 
 cmake ^
     -G "%CMAKE_GENERATOR%" ^
@@ -32,10 +35,10 @@ cmake ^
     -DBUILD_SHARED_LIBS=ON ^
     -DBUILD_TESTING=OFF ^
     -DCMAKE_OBJECT_PATH_MAX=255 ^
-    -DPYTHON_INSTALL_DIR=%SP_DIR_FORWARDSLASHES% ^
+    -DPYTHON_INSTALL_DIR=%SP_DIR% ^
     --compile-no-warning-as-error ^
-    %SRC_DIR%\%PKG_NAME%\src\work
+    %SRC_DIR%\src
 if errorlevel 1 exit 1
 
-cmake --build . --config Release --target install
+cmake --build . --config Release --target install -j8
 if errorlevel 1 exit 1

recipes/msgs/build_ament_cmake.sh

@@ -24,7 +24,7 @@ echo "USING PKG_CONFIG_EXECUTABLE=${PKG_CONFIG_EXECUTABLE}"
 export ROS_PYTHON_VERSION=`$PYTHON_EXECUTABLE -c "import sys; print('%i.%i' % (sys.version_info[0:2]))"`
 echo "Using Python ${ROS_PYTHON_VERSION}"
 # Fix up SP_DIR which for some reason might contain a path to a wrong Python version
-FIXED_SP_DIR=$(echo $SP_DIR | sed -E "s/python[0-9]+\.[0-9]+/python$ROS_PYTHON_VERSION/")
+FIXED_SP_DIR=$($PYTHON_EXECUTABLE -c "import site; print(site.getsitepackages()[0])")
 echo "Using site-package dir ${FIXED_SP_DIR}"
 
 # see https://github.com/conda-forge/cross-python-feedstock/issues/24
@@ -56,7 +56,6 @@ cmake \
     -DPYTHON_EXECUTABLE=$PYTHON_EXECUTABLE \
     -DPython_EXECUTABLE=$PYTHON_EXECUTABLE \
     -DPython3_EXECUTABLE=$PYTHON_EXECUTABLE \
-    -DPython3_FIND_STRATEGY=LOCATION \
     -DPKG_CONFIG_EXECUTABLE=$PKG_CONFIG_EXECUTABLE \
     -DPYTHON_INSTALL_DIR=$FIXED_SP_DIR \
     -DSETUPTOOLS_DEB_LAYOUT=OFF \
@@ -66,6 +65,6 @@ cmake \
     -DBUILD_TESTING=OFF \
     -DCMAKE_OSX_DEPLOYMENT_TARGET=$OSX_DEPLOYMENT_TARGET \
     --compile-no-warning-as-error \
-    $SRC_DIR/$PKG_NAME/src/work
+    $SRC_DIR/src
 
-cmake --build . --config Release --target install
+cmake --build . --config Release --target install -j8

recipes/msgs/recipe.yaml

@@ -0,0 +1,76 @@
+package:
+  name: ros-humble-unilabos-msgs
+  version: 0.10.6
+source:
+  path: ../../unilabos_msgs
+  target_directory: src
+
+build:
+  script:
+  - if: win
+    then:
+    - copy %RECIPE_DIR%\bld_ament_cmake.bat %SRC_DIR%
+    - call %SRC_DIR%\bld_ament_cmake.bat
+  - if: unix
+    then:
+    - cp $RECIPE_DIR/build_ament_cmake.sh $SRC_DIR
+    - bash $SRC_DIR/build_ament_cmake.sh
+
+about:
+  repository: https://github.com/dptech-corp/Uni-Lab-OS
+  license: BSD-3-Clause
+  description: "ros-humble-unilabos-msgs is a package that provides message definitions for Uni-Lab-OS."
+
+requirements:
+  build:
+  - ${{ compiler('cxx') }}
+  - ${{ compiler('c') }}
+  - python ==3.11.11
+  - numpy
+  - if: build_platform != target_platform
+    then:
+    - pkg-config
+    - cross-python_${{ target_platform }}
+  - if: linux and x86_64
+    then:
+    - sysroot_linux-64 ==2.17
+  - ninja
+  - setuptools
+  - cython
+  - cmake
+  - if: unix
+    then:
+    - make
+    - coreutils
+  - if: osx
+    then:
+    - tapi
+  - if: win
+    then:
+    - vs2022_win-64
+  host:
+  - numpy
+  - pip
+  - if: build_platform == target_platform
+    then:
+    - pkg-config
+  - robostack-staging::ros-humble-action-msgs
+  - robostack-staging::ros-humble-ament-cmake
+  - robostack-staging::ros-humble-ament-lint-auto
+  - robostack-staging::ros-humble-ament-lint-common
+  - robostack-staging::ros-humble-ros-environment
+  - robostack-staging::ros-humble-ros-workspace
+  - 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.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.6
+  - if: osx and x86_64
+    then:
+    - __osx >=${{ MACOSX_DEPLOYMENT_TARGET|default('10.14') }}

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

@@ -1,61 +0,0 @@
-package:
-  name: ros-humble-unilabos-msgs
-  version: 0.9.5
-source:
-  path: ../../unilabos_msgs
-  folder: ros-humble-unilabos-msgs/src/work
-
-build:
-  script:
-    sel(win): bld_ament_cmake.bat
-    sel(unix): build_ament_cmake.sh
-  number: 5
-about:
-  home: https://www.ros.org/
-  license: BSD-3-Clause
-  summary: |
-    Robot Operating System
-
-extra:
-  recipe-maintainers:
-    - ros-forge
-
-requirements:
-  build:
-    - "{{ compiler('cxx') }}"
-    - "{{ compiler('c') }}"
-    - sel(linux64): sysroot_linux-64 2.17
-    - ninja
-    - setuptools
-    - sel(unix): make
-    - sel(unix): coreutils
-    - sel(osx): tapi
-    - sel(build_platform != target_platform): pkg-config
-    - cmake
-    - cython
-    - sel(win): vs2022_win-64
-    - sel(build_platform != target_platform): python
-    - sel(build_platform != target_platform): cross-python_{{ target_platform }}
-    - sel(build_platform != target_platform): numpy
-  host:
-    - numpy
-    - pip
-    - sel(build_platform == target_platform): pkg-config
-    - robostack-staging::ros-humble-action-msgs
-    - robostack-staging::ros-humble-ament-cmake
-    - robostack-staging::ros-humble-ament-lint-auto
-    - robostack-staging::ros-humble-ament-lint-common
-    - robostack-staging::ros-humble-ros-environment
-    - robostack-staging::ros-humble-ros-workspace
-    - 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.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.6.*
-    - sel(osx and x86_64): __osx >={{ MACOSX_DEPLOYMENT_TARGET|default('10.14') }}

recipes/unilabos/recipe.yaml

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

setup.py

@@ -4,7 +4,7 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.9.5',
+    version='0.10.6',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],
@@ -16,7 +16,7 @@ setup(
     tests_require=['pytest'],
     entry_points={
         'console_scripts': [
-            "unilab = unilabos.app.main:main",
+            "unilab = unilabos.app.main:main"
         ],
     },
 )

test/commands/resource_add.md

@@ -3,3 +3,9 @@
 ```bash
 ros2 action send_goal /devices/host_node/create_resource_detailed unilabos_msgs/action/_resource_create_from_outer/ResourceCreateFromOuter "{ resources: [ { 'category': '', 'children': [], 'config': { 'type': 'Well', 'size_x': 6.86, 'size_y': 6.86, 'size_z': 10.67, 'rotation': { 'x': 0, 'y': 0, 'z': 0, 'type': 'Rotation' }, 'category': 'well', 'model': null, 'max_volume': 360, 'material_z_thickness': 0.5, 'compute_volume_from_height': null, 'compute_height_from_volume': null, 'bottom_type': 'flat', 'cross_section_type': 'circle' }, 'data': { 'liquids': [], 'pending_liquids': [], 'liquid_history': [] }, 'id': 'plate_well_11_7', 'name': 'plate_well_11_7', 'pose': { 'orientation': { 'w': 1.0, 'x': 0.0, 'y': 0.0, 'z': 0.0 }, 'position': { 'x': 0.0, 'y': 0.0, 'z': 0.0 } }, 'sample_id': '', 'parent': 'plate', 'type': 'device' } ], device_ids: [ 'PLR_STATION' ], bind_parent_ids: [ 'plate' ], bind_locations: [ { 'x': 0.0, 'y': 0.0, 'z': 0.0 } ], other_calling_params: [ '{}' ] }"
 ```
+
+使用mock_all.json启动，重新捕获MockContainerForChiller1
+
+```bash
+ros2 action send_goal /devices/host_node/create_resource unilabos_msgs/action/_resource_create_from_outer_easy/ResourceCreateFromOuterEasy "{ 'res_id': 'MockContainerForChiller1', 'device_id': 'MockChiller1', 'class_name': 'container', 'parent': 'MockChiller1', 'bind_locations': { 'x': 0.0, 'y': 0.0, 'z': 0.0 }, 'liquid_input_slot': [ -1 ], 'liquid_type': [ 'CuCl2' ], 'liquid_volume': [ 100.0 ], 'slot_on_deck': '' }"
+```

test/experiments/Protocol_Test_Station/add_protocol_test_station.json

@@ -0,0 +1,563 @@
+{
+    "nodes": [
+        {
+            "id": "AddProtocolTestStation",
+            "name": "添加协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2", 
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "stirrer_1",
+                "stirrer_2",
+                "flask_DMF",
+                "flask_ethyl_acetate", 
+                "flask_methanol",
+                "flask_acetone",
+                "flask_water",
+                "flask_air",
+                "main_reactor",
+                "secondary_reactor",
+                "waste_workup",
+                "collection_bottle_1",
+                "collection_bottle_2"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["PumpTransferProtocol", "AddProtocol"]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵1",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 250,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "转移泵2",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 750,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "试剂分配阀",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 250,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "反应器分配阀",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 750,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "stirrer_1",
+            "name": "主反应器搅拌器",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER1",
+                "max_speed": 1500.0,
+                "default_speed": 300.0
+            },
+            "data": {
+                "speed": 0.0,
+                "status": "Stopped"
+            }
+        },
+        {
+            "id": "stirrer_2",
+            "name": "副反应器搅拌器",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 900,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER2",
+                "max_speed": 1500.0,
+                "default_speed": 300.0
+            },
+            "data": {
+                "speed": 0.0,
+                "status": "Stopped"
+            }
+        },
+        {
+            "id": "flask_DMF",
+            "name": "DMF试剂瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 50,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "DMF",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯试剂瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 150,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇试剂瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 250,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮试剂瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 350,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 450,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 550,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "secondary_reactor",
+            "name": "副反应器",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液处理瓶",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_2",
+            "name": "收集瓶2",
+            "children": [],
+            "parent": "AddProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve1_DMF",
+            "source": "multiway_valve_1",
+            "target": "flask_DMF",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_DMF": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve2_main_reactor",
+            "source": "multiway_valve_2",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "main_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_secondary_reactor",
+            "source": "multiway_valve_2",
+            "target": "secondary_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "secondary_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection1",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection2",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "8",
+                "collection_bottle_2": "inlet"
+            }
+        },
+        {
+            "id": "link_stirrer1_main_reactor",
+            "source": "stirrer_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_1": "stirrer_head",
+                "main_reactor": "stirrer_port"
+            }
+        },
+        {
+            "id": "link_stirrer2_secondary_reactor",
+            "source": "stirrer_2",
+            "target": "secondary_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_2": "stirrer_head",
+                "secondary_reactor": "stirrer_port"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/centrifuge_protocol_test_station.json

@@ -0,0 +1,438 @@
+{
+    "nodes": [
+        {
+            "id": "CentrifugeProtocolTestStation",
+            "name": "离心协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2",
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "centrifuge_1",
+                "reaction_mixture",
+                "centrifuge_tube",
+                "collection_bottle_1",
+                "flask_water",
+                "flask_ethanol",
+                "flask_acetone",
+                "flask_air",
+                "waste_workup"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "CentrifugeProtocol",
+                    "PumpTransferProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "主转移泵",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 200,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "副转移泵",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 400,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "溶剂分配阀",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 200,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "样品分配阀",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 400,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "centrifuge_1",
+            "name": "离心机",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "device",
+            "class": "virtual_centrifuge",
+            "position": {
+                "x": 600,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_CENTRIFUGE1",
+                "max_speed": 15000.0,
+                "max_temp": 40.0,
+                "min_temp": 4.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "reaction_mixture",
+            "name": "反应混合物",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "cell_suspension",
+                        "liquid_volume": 200.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "centrifuge_tube",
+            "name": "离心管",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 15.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "上清液收集瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 900.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethanol",
+            "name": "乙醇清洗瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮清洗瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "CentrifugeProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve2_reaction_mixture",
+            "source": "multiway_valve_2",
+            "target": "reaction_mixture",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "reaction_mixture": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_centrifuge_tube",
+            "source": "multiway_valve_2",
+            "target": "centrifuge_tube",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "centrifuge_tube": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "4",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_centrifuge1_centrifuge_tube",
+            "source": "centrifuge_1",
+            "target": "centrifuge_tube",
+            "type": "transport",
+            "port": {
+                "centrifuge_1": "centrifuge",
+                "centrifuge_tube": "centrifuge_port"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/clean_vessel_protocol_test_station.json

@@ -0,0 +1,446 @@
+{
+    "nodes": [
+        {
+            "id": "CleanVesselProtocolTestStation",
+            "name": "容器清洗协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2",
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "heatchill_1",
+                "flask_water",
+                "flask_acetone",
+                "flask_ethanol",
+                "flask_air",
+                "main_reactor",
+                "secondary_reactor",
+                "waste_workup"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "CleanVesselProtocol",
+                    "PumpTransferProtocol",
+                    "HeatChillProtocol",
+                    "HeatChillStartProtocol",
+                    "HeatChillStopProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "主清洗泵",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 250,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 2.5
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "副清洗泵",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 450,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 2.5
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "溶剂分配阀",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 250,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "容器分配阀",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 450,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "heatchill_1",
+            "name": "加热清洗器",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 600,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL1",
+                "max_temp": 100.0,
+                "min_temp": 10.0,
+                "max_stir_speed": 500.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 50,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 900.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮清洗瓶",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 150,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethanol",
+            "name": "乙醇清洗瓶",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 250,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 350,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "residue",
+                        "liquid_volume": 50.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "secondary_reactor",
+            "name": "副反应器",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 800,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "organic_residue",
+                        "liquid_volume": 30.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "清洗废液瓶",
+            "children": [],
+            "parent": "CleanVesselProtocolTestStation",
+            "type": "container",
+            "class": "container",
+            "position": {
+                "x": 700,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 3000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+        "links": [
+        {
+            "id": "link_pump1_to_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_to_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_to_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_water": "top"
+            }
+        },
+        {
+            "id": "link_valve1_to_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_acetone": "top"
+            }
+        },
+        {
+            "id": "link_valve1_to_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_ethanol": "top"
+            }
+        },
+        {
+            "id": "link_valve1_to_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_to_valve2_for_cleaning",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "multiway_valve_2": "8"
+            }
+        },
+        {
+            "id": "link_valve2_to_main_reactor_in",
+            "source": "multiway_valve_2",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "main_reactor": "top"
+            }
+        },
+        {
+            "id": "link_valve2_to_secondary_reactor_in",
+            "source": "multiway_valve_2",
+            "target": "secondary_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "secondary_reactor": "top"
+            }
+        },
+        {
+            "id": "link_main_reactor_out_to_valve2",
+            "source": "main_reactor",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "main_reactor": "bottom",
+                "multiway_valve_2": "6"
+            }
+        },
+        {
+            "id": "link_secondary_reactor_out_to_valve2",
+            "source": "secondary_reactor",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "secondary_reactor": "bottom",
+                "multiway_valve_2": "7"
+            }
+        },
+        {
+            "id": "link_valve2_to_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "4",
+                "waste_workup": "top"
+            }
+        },
+        {
+            "id": "link_heatchill1_to_main_reactor",
+            "source": "heatchill_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "heatchill_1": "heatchill",
+                "main_reactor": "bind"
+            }
+        },
+        {
+            "id": "link_heatchill1_to_secondary_reactor",
+            "source": "heatchill_1",
+            "target": "secondary_reactor",
+            "type": "mechanical",
+            "port": {
+                "heatchill_1": "heatchill",
+                "secondary_reactor": "bind"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/dual_valve_pump_test_station.json

@@ -0,0 +1,367 @@
+{
+    "nodes": [
+        {
+            "id": "DualValvePumpStation",
+            "name": "双阀门泵站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2", 
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "flask_DMF",
+                "flask_ethyl_acetate", 
+                "flask_methanol",
+                "flask_air",
+                "main_reactor",
+                "waste_workup",
+                "collection_bottle_1"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["PumpTransferProtocol"]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵1",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 300,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "转移泵2",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 700,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "第一个八通阀",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 300,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "第二个八通阀",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 700,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "flask_DMF",
+            "name": "DMF试剂瓶",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "DMF",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯试剂瓶",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇试剂瓶",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液处理瓶",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "DualValvePumpStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_DMF",
+            "source": "multiway_valve_1",
+            "target": "flask_DMF",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_DMF": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve2_reactor",
+            "source": "multiway_valve_2",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "main_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "collection_bottle_1": "inlet"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/evacuateandrefill_test_station.json

@@ -0,0 +1,557 @@
+{
+    "nodes": [
+        {
+            "id": "EvacuateRefillTestStation",
+            "name": "抽真空充气测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2", 
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "flask_DMF",
+                "flask_ethyl_acetate", 
+                "flask_methanol",
+                "flask_air",
+                "vacuum_pump_1",
+                "gas_source_nitrogen",
+                "gas_source_air",
+                "solenoid_valve_vacuum",
+                "solenoid_valve_gas",
+                "main_reactor",
+                "stirrer_1",
+                "waste_workup",
+                "collection_bottle_1"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["PumpTransferProtocol", "EvacuateAndRefillProtocol"]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵1",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 300,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "转移泵2",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 700,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "第一个八通阀",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 300,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "第二个八通阀",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 700,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "vacuum_pump_1",
+            "name": "真空泵1",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_vacuum_pump",
+            "position": {
+                "x": 150,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VACUUM1",
+                "max_pressure": -0.9
+            },
+            "data": {
+                "status": "OFF",
+                "pressure": 0.0
+            }
+        },
+        {
+            "id": "gas_source_nitrogen",
+            "name": "氮气源",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_gas_source",
+            "position": {
+                "x": 850,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_GAS_N2",
+                "gas_type": "nitrogen",
+                "max_pressure": 5.0
+            },
+            "data": {
+                "status": "OFF",
+                "flow_rate": 0.0
+            }
+        },
+        {
+            "id": "gas_source_air",
+            "name": "空气源",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_gas_source",
+            "position": {
+                "x": 950,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_GAS_AIR",
+                "gas_type": "air",
+                "max_pressure": 3.0
+            },
+            "data": {
+                "status": "OFF",
+                "flow_rate": 0.0
+            }
+        },
+        {
+            "id": "solenoid_valve_vacuum",
+            "name": "真空电磁阀",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_solenoid_valve",
+            "position": {
+                "x": 225,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_SOLENOID_VACUUM"
+            },
+            "data": {
+                "valve_position": "CLOSED"
+            }
+        },
+        {
+            "id": "solenoid_valve_gas",
+            "name": "气源电磁阀",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_solenoid_valve",
+            "position": {
+                "x": 775,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_SOLENOID_GAS"
+            },
+            "data": {
+                "valve_position": "CLOSED"
+            }
+        },
+        {
+            "id": "flask_DMF",
+            "name": "DMF试剂瓶",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "DMF",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯试剂瓶",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇试剂瓶",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "stirrer_1",
+            "name": "搅拌器1",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER1",
+                "max_speed": 1500.0
+            },
+            "data": {
+                "speed": 0.0,
+                "status": "OFF"
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液处理瓶",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "EvacuateRefillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_vacuum_solenoid",
+            "source": "vacuum_pump_1",
+            "target": "solenoid_valve_vacuum",
+            "type": "fluid",
+            "port": {
+                "vacuum_pump_1": "outlet",
+                "solenoid_valve_vacuum": "inlet"
+            }
+        },
+        {
+            "id": "link_solenoid_vacuum_valve1",
+            "source": "solenoid_valve_vacuum",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "solenoid_valve_vacuum": "outlet",
+                "multiway_valve_1": "7"
+            }
+        },
+        {
+            "id": "link_gas_solenoid",
+            "source": "gas_source_nitrogen",
+            "target": "solenoid_valve_gas",
+            "type": "fluid",
+            "port": {
+                "gas_source_nitrogen": "outlet",
+                "solenoid_valve_gas": "inlet"
+            }
+        },
+        {
+            "id": "link_solenoid_gas_valve2",
+            "source": "solenoid_valve_gas",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "solenoid_valve_gas": "outlet",
+                "multiway_valve_2": "8"
+            }
+        },
+        {
+            "id": "link_air_source_valve2",
+            "source": "gas_source_air",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "gas_source_air": "outlet",
+                "multiway_valve_2": "2"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_DMF",
+            "source": "multiway_valve_1",
+            "target": "flask_DMF",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_DMF": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve2_reactor",
+            "source": "multiway_valve_2",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "main_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_stirrer_reactor",
+            "source": "stirrer_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_1": "stirrer",
+                "main_reactor": "stirrer"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/evaporate_protocol_test_station.json

@@ -0,0 +1,503 @@
+{
+    "nodes": [
+        {
+            "id": "EvaporateProtocolTestStation",
+            "name": "蒸发协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2", 
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "rotavap_1",
+                "heatchill_1",
+                "reaction_mixture",
+                "rotavap_flask",
+                "rotavap_condenser",
+                "flask_distillate",
+                "flask_ethanol",
+                "flask_acetone",
+                "flask_water",
+                "flask_air",
+                "waste_workup"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "EvaporateProtocol",
+                    "PumpTransferProtocol",
+                    "HeatChillProtocol",
+                    "HeatChillStartProtocol",
+                    "HeatChillStopProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "主转移泵",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 200,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 2.5
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "副转移泵",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 400,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 2.5
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "溶剂分配阀",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 200,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "容器分配阀",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 400,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "rotavap_1",
+            "name": "旋转蒸发仪",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_rotavap",
+            "position": {
+                "x": 700,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_ROTAVAP1",
+                "max_temp": 180.0,
+                "max_rotation_speed": 280.0
+            },
+            "data": {
+                "status": "Ready"
+            }
+        },
+        {
+            "id": "heatchill_1",
+            "name": "预加热器",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 100,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL1",
+                "max_temp": 100.0,
+                "min_temp": 10.0,
+                "max_stir_speed": 500.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "reaction_mixture",
+            "name": "反应混合物",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "reaction_mixture",
+                        "liquid_volume": 600.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "rotavap_flask",
+            "name": "旋蒸样品瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "rotavap_condenser",
+            "name": "旋蒸冷凝器",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_distillate",
+            "name": "溶剂回收瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_ethanol",
+            "name": "乙醇清洗瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 50,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮清洗瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 150,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 250,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 900.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 350,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "EvaporateProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 3000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_ethanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve2_reaction_mixture",
+            "source": "multiway_valve_2",
+            "target": "reaction_mixture",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "reaction_mixture": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_rotavap_flask",
+            "source": "multiway_valve_2",
+            "target": "rotavap_flask",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "rotavap_flask": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_rotavap_condenser",
+            "source": "multiway_valve_2",
+            "target": "rotavap_condenser",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "4",
+                "rotavap_condenser": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_distillate",
+            "source": "multiway_valve_2",
+            "target": "flask_distillate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "flask_distillate": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_rotavap1_rotavap_flask",
+            "source": "rotavap_1",
+            "target": "rotavap_flask",
+            "type": "fluid",
+            "port": {
+                "rotavap_1": "rotavap-sample",
+                "rotavap_flask": "rotavap_port"
+            }
+        },
+        {
+            "id": "link_heatchill1_reaction_mixture",
+            "source": "heatchill_1",
+            "target": "reaction_mixture",
+            "type": "mechanical",
+            "port": {
+                "heatchill_1": "heatchill",
+                "reaction_mixture": "heating_jacket"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/filter_protocol_test_station.json

@@ -0,0 +1,534 @@
+{
+    "nodes": [
+        {
+            "id": "FilterProtocolTestStation",
+            "name": "过滤协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2",
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "filter_1",
+                "heatchill_1",
+                "reaction_mixture",
+                "filter_vessel",
+                "filtrate_vessel",
+                "collection_bottle_1",
+                "collection_bottle_2",
+                "flask_water",
+                "flask_ethanol",
+                "flask_acetone",
+                "flask_air",
+                "waste_workup"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "FilterProtocol",
+                    "PumpTransferProtocol",
+                    "HeatChillProtocol",
+                    "HeatChillStartProtocol",
+                    "HeatChillStopProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "主转移泵",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 200,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "副转移泵",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 400,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "溶剂分配阀",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 200,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "样品分配阀",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 400,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "filter_1",
+            "name": "过滤器",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_filter",
+            "position": {
+                "x": 600,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_FILTER1",
+                "max_temp": 100.0,
+                "max_stir_speed": 1000.0,
+                "max_volume": 500.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "heatchill_1",
+            "name": "加热搅拌器",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL1",
+                "max_temp": 100.0,
+                "min_temp": 4.0,
+                "max_stir_speed": 1000.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "reaction_mixture",
+            "name": "反应混合物",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "cell_suspension",
+                        "liquid_volume": 200.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "filter_vessel",
+            "name": "过滤器容器",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "filtrate_vessel",
+            "name": "滤液收集容器",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_2",
+            "name": "收集瓶2",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 900.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethanol",
+            "name": "乙醇清洗瓶",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮清洗瓶",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "FilterProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve2_reaction_mixture",
+            "source": "multiway_valve_2",
+            "target": "reaction_mixture",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "reaction_mixture": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_filter_vessel",
+            "source": "multiway_valve_2",
+            "target": "filter_vessel",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "filter_vessel": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_filtrate_vessel",
+            "source": "multiway_valve_2",
+            "target": "filtrate_vessel",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "4",
+                "filtrate_vessel": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection1",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection2",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "collection_bottle_2": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_filter1_filter_vessel",
+            "source": "filter_1",
+            "target": "filter_vessel",
+            "type": "transport",
+            "port": {
+                "filter_1": "filter",
+                "filter_vessel": "filter_port"
+            }
+        },
+        {
+            "id": "link_heatchill1_filter_vessel",
+            "source": "heatchill_1",
+            "target": "filter_vessel",
+            "type": "mechanical",
+            "port": {
+                "heatchill_1": "heatchill",
+                "filter_vessel": "heating_jacket"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/heatchill_protocol_test_station.json

@@ -0,0 +1,671 @@
+{
+    "nodes": [
+        {
+            "id": "HeatChillProtocolTestStation",
+            "name": "加热冷却协议测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2", 
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "stirrer_1",
+                "stirrer_2",
+                "heatchill_1",
+                "heatchill_2",
+                "flask_DMF",
+                "flask_ethyl_acetate", 
+                "flask_methanol",
+                "flask_acetone",
+                "flask_water",
+                "flask_ethanol",
+                "flask_air",
+                "main_reactor",
+                "secondary_reactor",
+                "waste_workup",
+                "collection_bottle_1",
+                "collection_bottle_2"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "PumpTransferProtocol", 
+                    "AddProtocol", 
+                    "HeatChillProtocol", 
+                    "HeatChillStartProtocol", 
+                    "HeatChillStopProtocol",
+                    "DissolveProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵1",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 250,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "转移泵2",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 750,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "试剂分配阀",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 250,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "反应器分配阀",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 750,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "stirrer_1",
+            "name": "主反应器搅拌器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER1",
+                "max_speed": 1500.0,
+                "default_speed": 300.0
+            },
+            "data": {
+                "speed": 0.0,
+                "status": "Stopped"
+            }
+        },
+        {
+            "id": "stirrer_2",
+            "name": "副反应器搅拌器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 900,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER2",
+                "max_speed": 1500.0,
+                "default_speed": 300.0
+            },
+            "data": {
+                "speed": 0.0,
+                "status": "Stopped"
+            }
+        },
+        {
+            "id": "heatchill_1",
+            "name": "主反应器加热冷却器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 550,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL1",
+                "max_temp": 200.0,
+                "min_temp": -80.0,
+                "max_stir_speed": 1000.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "heatchill_2",
+            "name": "副反应器加热冷却器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 850,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL2",
+                "max_temp": 200.0,
+                "min_temp": -80.0,
+                "max_stir_speed": 1000.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "flask_DMF",
+            "name": "DMF试剂瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 50,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "DMF",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯试剂瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 150,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇试剂瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 250,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+                {
+            "id": "flask_ethanol",
+            "name": "乙醇试剂瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 650,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮试剂瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 350,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 450,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 550,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "secondary_reactor",
+            "name": "副反应器",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液处理瓶",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_2",
+            "name": "收集瓶2",
+            "children": [],
+            "parent": "HeatChillProtocolTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve1_DMF",
+            "source": "multiway_valve_1",
+            "target": "flask_DMF",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_DMF": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve2_main_reactor",
+            "source": "multiway_valve_2",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "main_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_secondary_reactor",
+            "source": "multiway_valve_2",
+            "target": "secondary_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "secondary_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_waste",
+            "source": "multiway_valve_2",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection1",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_collection2",
+            "source": "multiway_valve_2",
+            "target": "collection_bottle_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "8",
+                "collection_bottle_2": "inlet"
+            }
+        },
+        {
+            "id": "link_stirrer1_main_reactor",
+            "source": "stirrer_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_1": "stirrer_head",
+                "main_reactor": "stirrer_port"
+            }
+        },
+        {
+            "id": "link_stirrer2_secondary_reactor",
+            "source": "stirrer_2",
+            "target": "secondary_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_2": "stirrer_head",
+                "secondary_reactor": "stirrer_port"
+            }
+        },
+        {
+            "id": "link_heatchill1_main_reactor",
+            "source": "heatchill_1",
+            "target": "main_reactor",
+            "type": "thermal",
+            "port": {
+                "heatchill_1": "heating_surface",
+                "main_reactor": "heating_jacket"
+            }
+        },
+        {
+            "id": "link_heatchill2_secondary_reactor",
+            "source": "heatchill_2",
+            "target": "secondary_reactor",
+            "type": "thermal",
+            "port": {
+                "heatchill_2": "heating_surface",
+                "secondary_reactor": "heating_jacket"
+            }
+        },
+        {
+            "id": "link_valve1_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "7",
+                "flask_ethanol": "outlet"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/pumptransfer_filterthrough_test_station.json

@@ -0,0 +1,778 @@
+{
+    "nodes": [
+        {
+            "id": "PumpTransferFilterThroughTestStation",
+            "name": "泵转移+过滤介质测试站",
+            "children": [
+                "transfer_pump_1",
+                "transfer_pump_2",
+                "multiway_valve_1",
+                "multiway_valve_2",
+                "reaction_mixture",
+                "crude_product",
+                "filter_celite",
+                "column_silica_gel",
+                "filter_C18",
+                "pure_product",
+                "collection_bottle_1",
+                "collection_bottle_2",
+                "collection_bottle_3",
+                "intermediate_vessel_1",
+                "intermediate_vessel_2",
+                "flask_water",
+                "flask_ethanol",
+                "flask_methanol",
+                "flask_ethyl_acetate",
+                "flask_acetone",
+                "flask_hexane",
+                "flask_air",
+                "waste_workup"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "PumpTransferProtocol",
+                    "FilterThroughProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "主转移泵",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 200,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "transfer_pump_2",
+            "name": "副转移泵",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 400,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP2",
+                "max_volume": 25.0,
+                "transfer_rate": 2.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "溶剂分配阀",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 200,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "multiway_valve_2",
+            "name": "样品分配阀",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 400,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE2",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "reaction_mixture",
+            "name": "反应混合物",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "organic_reaction_mixture",
+                        "liquid_volume": 250.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "crude_product",
+            "name": "粗产品",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "crude_organic_compound",
+                        "liquid_volume": 150.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "filter_celite",
+            "name": "硅藻土过滤器",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 300.0,
+                "filter_type": "celite_pad"
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "column_silica_gel",
+            "name": "硅胶柱",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 200.0,
+                "filter_type": "silica_gel_column"
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "filter_C18",
+            "name": "C18固相萃取柱",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 100.0,
+                "filter_type": "C18_cartridge"
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "pure_product",
+            "name": "纯产品",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_2",
+            "name": "收集瓶2",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_3",
+            "name": "收集瓶3",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 550,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "intermediate_vessel_1",
+            "name": "中间容器1",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "intermediate_vessel_2",
+            "name": "中间容器2",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_water",
+            "name": "蒸馏水瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 900.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethanol",
+            "name": "乙醇瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "丙酮瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 500,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_hexane",
+            "name": "正己烷瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "hexane",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "PumpTransferFilterThroughTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 600,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump1_valve1",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_pump2_valve2",
+            "source": "transfer_pump_2",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_2": "transferpump",
+                "multiway_valve_2": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve1_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve1_water",
+            "source": "multiway_valve_1",
+            "target": "flask_water",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_water": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethanol",
+            "source": "multiway_valve_1",
+            "target": "flask_ethanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_acetone",
+            "source": "multiway_valve_1",
+            "target": "flask_acetone",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "flask_acetone": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_hexane",
+            "source": "multiway_valve_1",
+            "target": "flask_hexane",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "7",
+                "flask_hexane": "outlet"
+            }
+        },
+        {
+            "id": "link_valve1_valve2",
+            "source": "multiway_valve_1",
+            "target": "multiway_valve_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "multiway_valve_2": "1"
+            }
+        },
+        {
+            "id": "link_valve2_reaction_mixture",
+            "source": "multiway_valve_2",
+            "target": "reaction_mixture",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "2",
+                "reaction_mixture": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_crude_product",
+            "source": "multiway_valve_2",
+            "target": "crude_product",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "3",
+                "crude_product": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_intermediate1",
+            "source": "multiway_valve_2",
+            "target": "intermediate_vessel_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "4",
+                "intermediate_vessel_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_intermediate2",
+            "source": "multiway_valve_2",
+            "target": "intermediate_vessel_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "5",
+                "intermediate_vessel_2": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_celite",
+            "source": "multiway_valve_2",
+            "target": "filter_celite",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "6",
+                "filter_celite": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_silica_gel",
+            "source": "multiway_valve_2",
+            "target": "column_silica_gel",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "7",
+                "column_silica_gel": "inlet"
+            }
+        },
+        {
+            "id": "link_valve2_C18",
+            "source": "multiway_valve_2",
+            "target": "filter_C18",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_2": "8",
+                "filter_C18": "inlet"
+            }
+        },
+        {
+            "id": "link_celite_collection1",
+            "source": "filter_celite",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "filter_celite": "outlet",
+                "collection_bottle_1": "inlet"
+            }
+        },
+        {
+            "id": "link_silica_gel_collection2",
+            "source": "column_silica_gel",
+            "target": "collection_bottle_2",
+            "type": "fluid",
+            "port": {
+                "column_silica_gel": "outlet",
+                "collection_bottle_2": "inlet"
+            }
+        },
+        {
+            "id": "link_C18_collection3",
+            "source": "filter_C18",
+            "target": "collection_bottle_3",
+            "type": "fluid",
+            "port": {
+                "filter_C18": "outlet",
+                "collection_bottle_3": "inlet"
+            }
+        },
+        {
+            "id": "link_collection1_pure_product",
+            "source": "collection_bottle_1",
+            "target": "pure_product",
+            "type": "fluid",
+            "port": {
+                "collection_bottle_1": "outlet",
+                "pure_product": "inlet"
+            }
+        },
+        {
+            "id": "link_collection2_pure_product",
+            "source": "collection_bottle_2",
+            "target": "pure_product",
+            "type": "fluid",
+            "port": {
+                "collection_bottle_2": "outlet",
+                "pure_product": "inlet"
+            }
+        },
+        {
+            "id": "link_collection3_pure_product",
+            "source": "collection_bottle_3",
+            "target": "pure_product",
+            "type": "fluid",
+            "port": {
+                "collection_bottle_3": "outlet",
+                "pure_product": "inlet"
+            }
+        },
+        {
+            "id": "link_waste_connection",
+            "source": "pure_product",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "pure_product": "waste_outlet",
+                "waste_workup": "inlet"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/pumptransfer_test_station.json

@@ -0,0 +1,304 @@
+{
+    "nodes": [
+        {
+            "id": "SimpleProtocolStation",
+            "name": "简单协议工作站",
+            "children": [
+                "transfer_pump_1",
+                "multiway_valve_1",
+                "flask_DMF",
+                "flask_ethyl_acetate", 
+                "flask_methanol",
+                "main_reactor",
+                "waste_workup",
+                "collection_bottle_1",
+                "flask_air"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["PumpTransferProtocol"]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵1",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 500,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL",
+                "max_volume": 25.0,
+                "transfer_rate": 5.0
+            },
+            "data": {
+                "position": 0.0,
+                "status": "Idle",
+                "valve_position": "0"
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "八通阀1",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 500,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "flask_DMF",
+            "name": "DMF试剂瓶",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "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
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯试剂瓶",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "ethyl_acetate",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇试剂瓶",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "methanol",
+                        "liquid_volume": 800.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "废液处理瓶",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_bottle_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "空气瓶",
+            "children": [],
+            "parent": "SimpleProtocolStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump_valve",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump", 
+                "multiway_valve_1": "transferpump"  
+            }
+        },
+        {
+            "id": "link_valve_air",
+            "source": "multiway_valve_1",
+            "target": "flask_air",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_air": "top"
+            }
+        },
+        {
+            "id": "link_valve_DMF",
+            "source": "multiway_valve_1",
+            "target": "flask_DMF",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_DMF": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_reactor",
+            "source": "multiway_valve_1",
+            "target": "main_reactor",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "main_reactor": "inlet"
+            }
+        },
+        {
+            "id": "link_valve_waste",
+            "source": "multiway_valve_1",
+            "target": "waste_workup",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "waste_workup": "inlet"
+            }
+        },
+        {
+            "id": "link_valve_collection",
+            "source": "multiway_valve_1",
+            "target": "collection_bottle_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "7",
+                "collection_bottle_1": "inlet"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/run_column_protocol_test_station.json

@@ -0,0 +1,432 @@
+{
+    "nodes": [
+        {
+            "id": "RunColumnTestStation",
+            "name": "柱层析测试工作站",
+            "children": [
+                "transfer_pump_1",
+                "multiway_valve_1",
+                "column_1",
+                "flask_sample",
+                "flask_hexane",
+                "flask_ethyl_acetate",
+                "flask_methanol",
+                "column_vessel",
+                "collection_flask_1",
+                "collection_flask_2",
+                "collection_flask_3",
+                "waste_flask",
+                "main_reactor"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["RunColumnProtocol", "PumpTransferProtocol"]
+            },
+            "data": {}
+        },
+        {
+            "id": "transfer_pump_1",
+            "name": "转移泵",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "device",
+            "class": "virtual_transfer_pump",
+            "position": {
+                "x": 300,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_PUMP1",
+                "max_volume": 50.0,
+                "transfer_rate": 10.0
+            },
+            "data": {
+                "status": "Idle",
+                "position": 0.0
+            }
+        },
+        {
+            "id": "multiway_valve_1",
+            "name": "八通阀门",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 300,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_VALVE1",
+                "positions": 8
+            },
+            "data": {
+                "current_position": 1
+            }
+        },
+        {
+            "id": "column_1",
+            "name": "柱层析设备",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "device",
+            "class": "virtual_column",
+            "position": {
+                "x": 600,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_COLUMN1",
+                "max_flow_rate": 5.0,
+                "column_length": 30.0,
+                "column_diameter": 2.5
+            },
+            "data": {
+                "status": "Idle",
+                "column_state": "Ready"
+            }
+        },
+        {
+            "id": "flask_sample",
+            "name": "样品瓶",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 100,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 500.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "crude_mixture",
+                        "volume": 200.0,
+                        "concentration": 70.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_hexane",
+            "name": "正己烷洗脱剂",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 200,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "hexane",
+                        "volume": 1500.0,
+                        "concentration": 99.8
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_ethyl_acetate",
+            "name": "乙酸乙酯洗脱剂",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 300,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "ethyl_acetate",
+                        "volume": 1500.0,
+                        "concentration": 99.5
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_methanol",
+            "name": "甲醇洗脱剂",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 400,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "methanol",
+                        "volume": 800.0,
+                        "concentration": 99.9
+                    }
+                ]
+            }
+        },
+        {
+            "id": "column_vessel",
+            "name": "柱容器",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 300.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_flask_1",
+            "name": "收集瓶1",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_flask_2",
+            "name": "收集瓶2",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 800,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "collection_flask_3",
+            "name": "收集瓶3",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 900,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "waste_flask",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1000,
+                "y": 500,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "反应器",
+            "children": [],
+            "parent": "RunColumnTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 600,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "reaction_mixture",
+                        "volume": 300.0,
+                        "concentration": 85.0
+                    }
+                ]
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_pump_valve",
+            "source": "transfer_pump_1",
+            "target": "multiway_valve_1",
+            "type": "fluid",
+            "port": {
+                "transfer_pump_1": "transferpump",
+                "multiway_valve_1": "transferpump"
+            }
+        },
+        {
+            "id": "link_valve_sample",
+            "source": "multiway_valve_1",
+            "target": "flask_sample",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "1",
+                "flask_sample": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_hexane",
+            "source": "multiway_valve_1",
+            "target": "flask_hexane",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "2",
+                "flask_hexane": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_ethyl_acetate",
+            "source": "multiway_valve_1",
+            "target": "flask_ethyl_acetate",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "3",
+                "flask_ethyl_acetate": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_methanol",
+            "source": "multiway_valve_1",
+            "target": "flask_methanol",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "4",
+                "flask_methanol": "outlet"
+            }
+        },
+        {
+            "id": "link_valve_column_vessel",
+            "source": "multiway_valve_1",
+            "target": "column_vessel",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "5",
+                "column_vessel": "inlet"
+            }
+        },
+        {
+            "id": "link_valve_collection1",
+            "source": "multiway_valve_1",
+            "target": "collection_flask_1",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "6",
+                "collection_flask_1": "inlet"
+            }
+        },
+        {
+            "id": "link_valve_collection2",
+            "source": "multiway_valve_1",
+            "target": "collection_flask_2",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "7",
+                "collection_flask_2": "inlet"
+            }
+        },
+        {
+            "id": "link_valve_waste",
+            "source": "multiway_valve_1",
+            "target": "waste_flask",
+            "type": "fluid",
+            "port": {
+                "multiway_valve_1": "8",
+                "waste_flask": "inlet"
+            }
+        },
+        {
+            "id": "link_column_device_vessel",
+            "source": "column_1",
+            "target": "column_vessel",
+            "type": "transport",
+            "port": {
+                "column_1": "columnin",
+                "column_vessel": "column_port"
+            }
+        },
+        {
+            "id": "link_column_collection3",
+            "source": "column_1",
+            "target": "collection_flask_3",
+            "type": "transport",
+            "port": {
+                "column_1": "columnout",
+                "collection_flask_3": "column_outlet"
+            }
+        }
+    ]
+}

test/experiments/Protocol_Test_Station/simple_stir_heatchill_test_station.json

@@ -0,0 +1,141 @@
+{
+    "nodes": [
+        {
+            "id": "SimpleStirHeatChillTestStation",
+            "name": "搅拌加热测试站",
+            "children": [
+                "stirrer_1",
+                "heatchill_1",
+                "main_reactor",
+                "secondary_reactor"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 500,
+                "y": 200,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": [
+                    "StirProtocol",
+                    "StartStirProtocol", 
+                    "StopStirProtocol",
+                    "HeatChillProtocol", 
+                    "HeatChillStartProtocol", 
+                    "HeatChillStopProtocol"
+                ]
+            },
+            "data": {}
+        },
+        {
+            "id": "stirrer_1",
+            "name": "主搅拌器",
+            "children": [],
+            "parent": "SimpleStirHeatChillTestStation",
+            "type": "device",
+            "class": "virtual_stirrer",
+            "position": {
+                "x": 400,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_STIRRER1",
+                "max_speed": 1500.0,
+                "min_speed": 50.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "heatchill_1",
+            "name": "主加热冷却器",
+            "children": [],
+            "parent": "SimpleStirHeatChillTestStation",
+            "type": "device",
+            "class": "virtual_heatchill",
+            "position": {
+                "x": 600,
+                "y": 350,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL_HEATCHILL1",
+                "max_temp": 200.0,
+                "min_temp": -80.0,
+                "max_stir_speed": 1000.0
+            },
+            "data": {
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "main_reactor",
+            "name": "主反应器",
+            "children": [],
+            "parent": "SimpleStirHeatChillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 500,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "water",
+                        "liquid_volume": 500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "secondary_reactor",
+            "name": "副反应器",
+            "children": [],
+            "parent": "SimpleStirHeatChillTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 700,
+                "y": 450,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        }
+    ],
+    "links": [
+        {
+            "id": "link_stirrer1_main_reactor",
+            "source": "stirrer_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "stirrer_1": "stirrer",
+                "main_reactor": "stirrer_port"
+            }
+        },
+        {
+            "id": "link_heatchill1_main_reactor",
+            "source": "heatchill_1",
+            "target": "main_reactor",
+            "type": "mechanical",
+            "port": {
+                "heatchill_1": "heatchill",
+                "main_reactor": "heating_jacket"
+            }
+        }
+    ]
+}

test/experiments/camera.json

@@ -0,0 +1,45 @@
+{
+    "nodes": [
+        {
+            "id": "Camera",
+            "name": "摄像头",
+            "children": [
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "camera",
+            "position": {
+                "x": 0,
+                "y": 0,
+                "z": 0
+            },
+            "config": {
+                "camera_index": 0,
+                "period": 0.05
+            },
+            "data": {
+            }
+        },
+        {
+            "id": "Gripper1",
+            "name": "假夹爪",
+            "children": [
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "gripper.mock",
+            "position": {
+                "x": 0,
+                "y": 0,
+                "z": 0
+            },
+            "config": {
+            },
+            "data": {
+            }
+        }
+    ],
+    "links": [
+        
+    ]
+}

test/experiments/comprehensive_protocol/checklist.md

@@ -0,0 +1,258 @@
+1. 用到的仪器
+                virtual_multiway_valve(√)                                                     八通阀门
+                virtual_transfer_pump(√)                                                        转移泵
+                virtual_centrifuge()                                                            离心机
+                virtual_rotavap()                                                               旋蒸仪
+                virtual_heatchill()                                                             加热器
+                virtual_stirrer()                                                               搅拌器
+                virtual_solenoid_valve()                                                        电磁阀
+                virtual_vacuum_pump(√)                       vacuum_pump.mock                            真空泵
+                virtual_gas_source(√)                                                                    气源
+                virtual_filter()                                                                过滤器
+                virtual_column(√)                                                               层析柱
+                separator()                         homemade_grbl_conductivity                  分液漏斗
+2. 用到的protocol
+    PumpTransferProtocol: generate_pump_protocol_with_rinsing,                      (√)
+    这个重复了，删掉CleanProtocol: generate_clean_protocol,
+    SeparateProtocol: generate_separate_protocol,                           (×)
+    EvaporateProtocol: generate_evaporate_protocol,                                 (√)
+    EvacuateAndRefillProtocol: generate_evacuateandrefill_protocol,                 (√)
+    CentrifugeProtocol: generate_centrifuge_protocol,                               (√)
+    AddProtocol: generate_add_protocol,                                             (√)
+    FilterProtocol: generate_filter_protocol,                                       (√)
+    HeatChillProtocol: generate_heat_chill_protocol,                                (√)
+    HeatChillStartProtocol: generate_heat_chill_start_protocol,                     (√)
+    HeatChillStopProtocol: generate_heat_chill_stop_protocol,                       (√)
+    HeatChillToTempProtocol:
+    StirProtocol: generate_stir_protocol,                                           (√)
+    StartStirProtocol: generate_start_stir_protocol,                                (√)
+    StopStirProtocol: generate_stop_stir_protocol,                                  (√)
+    这个重复了，删掉TransferProtocol: generate_transfer_protocol,
+    CleanVesselProtocol: generate_clean_vessel_protocol,                            (√)
+    DissolveProtocol: generate_dissolve_protocol,                                   (√)
+    FilterThroughProtocol: generate_filter_through_protocol,                        (√)
+    RunColumnProtocol: generate_run_column_protocol,                                (√)<RunColumn Rf="?" column="column" from_vessel="rotavap" ratio="5:95" solvent1="methanol" solvent2="chloroform" to_vessel="rotavap"/>
+
+上下文体积搜索
+3. 还没创建的protocol
+    ResetHandling                         写完了                               <ResetHandling solvent="methanol"/>
+    Dry                                  写完了                                 <Dry compound="product" vessel="filter"/>
+    AdjustPH                               写完了                                <AdjustPH pH="8.0" reagent="hydrochloric acid" vessel="main_reactor"/>
+    Recrystallize                          写完了                              <Recrystallize ratio="?" solvent1="dichloromethane" solvent2="methanol" vessel="filter" volume="?"/>
+    TakeSample                                                                  <TakeSample id="a" vessel="rotavap"/>
+    Hydrogenate                                                                 <Hydrogenate temp="45 °C" time="?" vessel="main_reactor"/>
+4. 参数对齐
+
+
+
+
+
+
+
+
+
+
+class PumpTransferProtocol(BaseModel):
+    from_vessel: str
+    to_vessel: str
+    volume: float
+    amount: str = ""
+    time: float = 0
+    viscous: bool = False
+    rinsing_solvent: str = "air"        <Transfer from_vessel="main_reactor" to_vessel="rotavap"/>
+    rinsing_volume: float = 5000        <Transfer event="A" from_vessel="reactor" rate_spec="dropwise" to_vessel="main_reactor"/>
+    rinsing_repeats: int = 2            <Transfer from_vessel="separator" through="cartridge" to_vessel="rotavap"/>
+    solid: bool = False                 测完了三个都能跑✅
+    flowrate: float = 500
+    transfer_flowrate: float = 2500
+
+class SeparateProtocol(BaseModel):
+    purpose: str
+    product_phase: str
+    from_vessel: str
+    separation_vessel: str
+    to_vessel: str
+    waste_phase_to_vessel: str
+    solvent: str
+    solvent_volume: float               <Separate product_phase="bottom" purpose="wash" solvent="water" vessel="separator" volume="?"/>
+    through: str                        <Separate product_phase="top" purpose="separate" vessel="separator"/>
+    repeats: int                        <Separate product_phase="bottom" purpose="extract" repeats="3" solvent="CH2Cl2" vessel="separator" volume="?"/>
+    stir_time: float                    <Separate product_phase="top" product_vessel="flask" purpose="separate" vessel="separator" waste_vessel="separator"/>
+    stir_speed: float
+    settling_time: float                测完了能跑✅
+
+
+class EvaporateProtocol(BaseModel):
+    vessel: str
+    pressure: float
+    temp: float                         <Evaporate solvent="ethanol" vessel="rotavap"/>
+    time: float                         测完了能跑✅
+    stir_speed: float
+
+
+class EvacuateAndRefillProtocol(BaseModel):
+    vessel: str
+    gas: str                            <EvacuateAndRefill gas="nitrogen" vessel="main_reactor"/>
+    repeats: int                        测完了能跑✅
+
+class AddProtocol(BaseModel):
+    vessel: str
+    reagent: str
+    volume: float
+    mass: float
+    amount: str
+    time: float
+    stir: bool
+    stir_speed: float                   <Add reagent="ethanol" vessel="main_reactor" volume="2.7 mL"/>
+    <Add event="A" mass="19.3 g" mol="0.28 mol" rate_spec="portionwise" reagent="sodium nitrite" time="1 h" vessel="main_reactor"/>
+    <Add mass="4.5 g" mol="16.2 mmol" reagent="(S)-2-phthalimido-6-hydroxyhexanoic acid" vessel="main_reactor"/>
+    <Add purpose="dilute" reagent="hydrochloric acid" vessel="main_reactor" volume="?"/>
+    <Add equiv="1.1" event="B" mol="25.2 mmol" rate_spec="dropwise" reagent="1-fluoro-2-nitrobenzene" time="20 min" 
+    vessel="main_reactor" volume="2.67 mL"/>
+    <Add ratio="?" reagent="tetrahydrofuran|tert-butanol" vessel="main_reactor" volume="?"/>
+    viscous: bool
+    purpose: str                        测完了能跑✅
+
+class CentrifugeProtocol(BaseModel):
+    vessel: str
+    speed: float
+    time: float                         没毛病
+    temp: float
+
+class FilterProtocol(BaseModel):
+    vessel: str
+    filtrate_vessel: str
+    stir: bool                          <Filter vessel="filter"/>
+    stir_speed: float                   <Filter filtrate_vessel="rotavap" vessel="filter"/>
+    temp: float                         测完了能跑✅
+    continue_heatchill: bool
+    volume: float
+
+class HeatChillProtocol(BaseModel):
+    vessel: str
+    temp: float
+    time: float                         <HeatChill pressure="1 mbar" temp_spec="room temperature" time="?" vessel="main_reactor"/>
+                                        <HeatChill temp_spec="room temperature" time_spec="overnight" vessel="main_reactor"/>
+                                        <HeatChill temp="256 °C" time="?" vessel="main_reactor"/>
+                                        <HeatChill reflux_solvent="methanol" temp_spec="reflux" time="2 h" vessel="main_reactor"/>
+                                        <HeatChillToTemp temp_spec="room temperature" vessel="main_reactor"/>
+    stir: bool                          测完了能跑✅
+    stir_speed: float
+    purpose: str
+
+class HeatChillStartProtocol(BaseModel):
+    vessel: str
+    temp: float                     疑似没有
+    purpose: str
+
+class HeatChillStopProtocol(BaseModel):
+    vessel: str                     疑似没有
+
+class StirProtocol(BaseModel):
+    stir_time: float
+    stir_speed: float               <Stir time="0.5 h" vessel="main_reactor"/>
+                                    <Stir event="A" time="30 min" vessel="main_reactor"/>
+                                    <Stir time_spec="several minutes" vessel="filter"/>
+    settling_time: float            测完了能跑✅
+
+class StartStirProtocol(BaseModel):
+    vessel: str
+    stir_speed: float               疑似没有
+    purpose: str
+
+class StopStirProtocol(BaseModel):
+    vessel: str                     疑似没有
+
+class TransferProtocol(BaseModel):
+    from_vessel: str
+    to_vessel: str
+    volume: float
+    amount: str = ""
+    time: float = 0
+    viscous: bool = False   
+    rinsing_solvent: str = ""
+    rinsing_volume: float = 0.0
+    rinsing_repeats: int = 0
+    solid: bool = False             这个protocol早该删掉了
+
+class CleanVesselProtocol(BaseModel):
+    vessel: str
+    solvent: str
+    volume: float
+    temp: float
+    repeats: int = 1                    <CleanVessel vessel="centrifuge"/>
+
+class DissolveProtocol(BaseModel):
+    vessel: str
+    solvent: str
+    volume: float       <Dissolve mass="2.9 g" mol="0.12 mol" reagent="magnesium" vessel="main_reactor"/>
+    amount: str = ""    <Dissolve mass="12.9 g" reagent="4-tert-butylbenzyl bromide" vessel="main_reactor"/>
+    temp: float = 25.0  <Dissolve solvent="diisopropyl ether" vessel="rotavap" volume="?"/>
+    time: float = 0.0   <Dissolve event="A" mass="?" reagent="pyridinone" vessel="main_reactor"/>
+    stir_speed: float = 0.0     测完了能跑✅
+
+class FilterThroughProtocol(BaseModel):
+    from_vessel: str
+    to_vessel: str
+    filter_through: str
+    eluting_solvent: str = ""
+    eluting_volume: float = 0.0                 疑似没有
+    eluting_repeats: int = 0
+    residence_time: float = 0.0
+
+class RunColumnProtocol(BaseModel):
+    from_vessel: str
+    to_vessel: str              <RunColumn Rf="?" column="column" from_vessel="rotavap" pct1="40 %" pct2="50 %" solvent1="ethyl acetate" solvent2="hexane" to_vessel="rotavap"/>
+    column: str                 测完了能跑✅
+
+class WashSolidProtocol(BaseModel):
+    vessel: str
+    solvent: str
+    volume: float
+    filtrate_vessel: str = ""   <WashSolid repeats="4" solvent="water" vessel="main_reactor" volume="400 mL"/>
+    temp: float = 25.0          <WashSolid filtrate_vessel="rotavap" solvent="formic acid" vessel="main_reactor" volume="?"/>
+    stir: bool = False          <WashSolid solvent="acetone" vessel="rotavap" volume="5 mL"/>
+                                <WashSolid solvent="ethyl alcohol" vessel="main_reactor" volume_spec="small volume"/>
+                                <WashSolid filtrate_vessel="rotavap" mass="10 g" solvent="toluene" vessel="separator"/>
+                                <WashSolid repeats_spec="several" solvent="water" vessel="main_reactor" volume="?"/>
+    stir_speed: float = 0.0     测完了能跑✅
+    time: float = 0.0
+    repeats: int = 1
+
+class AdjustPHProtocol(BaseModel):
+    vessel: str = Field(..., description="目标容器")
+    ph_value: float = Field(..., description="目标pH值")  # 改为 ph_value
+    reagent: str = Field(..., description="酸碱试剂名称")
+    # 移除其他可选参数，使用默认值                                                   <新写的，没问题>
+
+class ResetHandlingProtocol(BaseModel):
+    solvent: str = Field(..., description="溶剂名称")                               <新写的，没问题>
+
+class DryProtocol(BaseModel):
+    compound: str = Field(..., description="化合物名称")                            <新写的，没问题>
+    vessel: str = Field(..., description="目标容器")
+
+class RecrystallizeProtocol(BaseModel):
+    ratio: str = Field(..., description="溶剂比例（如 '1:1', '3:7'）")
+    solvent1: str = Field(..., description="第一种溶剂名称")                        <新写的，没问题>
+    solvent2: str = Field(..., description="第二种溶剂名称")
+    vessel: str = Field(..., description="目标容器")
+    volume: float = Field(..., description="总体积 (mL)")
+
+class HydrogenateProtocol(BaseModel):
+    temp: str = Field(..., description="反应温度（如 '45 °C'）")
+    time: str = Field(..., description="反应时间（如 '2 h'）")                          <新写的，没问题>
+    vessel: str = Field(..., description="反应容器")
+
+    还差
+    <dissolve>
+    <separate>
+    <CleanVessel vessel="centrifuge"/>
+
+
+单位修复：
+    evaporate
+    heatchill
+    recrysitallize
+    stir
+    wash solid

test/experiments/dispensing_station_bioyond.json

@@ -0,0 +1,60 @@
+{
+    "nodes": [
+        {
+            "id": "dispensing_station_bioyond",
+            "name": "dispensing_station_bioyond",
+            "children": [
+                "Bioyond_Dispensing_Deck"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "dispensing_station.bioyond",
+            "config": {
+                "config": {
+                    "api_key": "DE9BDDA0",
+                    "api_host": "http://192.168.1.200:44388"
+                },
+                "deck": {
+                    "data": {
+                        "_resource_child_name": "Bioyond_Dispensing_Deck",
+                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerPreparationStation_Deck"
+                    }
+                },
+                "station_config": {
+                    "station_type": "dispensing_station",
+                    "enable_dispensing_station": true,
+                    "enable_reaction_station": false,
+                    "station_name": "DispensingStation_001",
+                    "description": "Bioyond配液工作站"
+                },
+                "protocol_type": []
+            },
+            "data": {}
+        },
+        {
+            "id": "Bioyond_Dispensing_Deck",
+            "name": "Bioyond_Dispensing_Deck",
+            "sample_id": null,
+            "children": [],
+            "parent": "dispensing_station_bioyond",
+            "type": "deck",
+            "class": "BIOYOND_PolymerPreparationStation_Deck",
+            "position": {
+                "x": 0,
+                "y": 0,
+                "z": 0
+            },
+            "config": {
+                "type": "BIOYOND_PolymerPreparationStation_Deck",
+                "setup": true,
+                "rotation": {
+                    "x": 0,
+                    "y": 0,
+                    "z": 0,
+                    "type": "Rotation"
+                }
+            },
+            "data": {}
+        }
+    ]
+}

test/experiments/mock_devices/mock_all.json

@@ -3,7 +3,9 @@
         {  
             "id": "MockChiller1",  
             "name": "模拟冷却器",  
-            "children": [],  
+            "children": [
+                "MockContainerForChiller1"
+            ],
             "parent": null,  
             "type": "device",  
             "class": "mock_chiller",  
@@ -25,6 +27,22 @@
                 "purpose": ""
             }  
         },
+        {
+            "id": "MockContainerForChiller1",
+            "name": "模拟容器",
+            "type": "container",
+            "parent": "MockChiller1",
+            "position": {
+                "x": 5,
+                "y": 0,
+                "z": 0
+            },
+            "data": {
+                "liquid_type": "CuCl2",
+                "liquid_volume": "100"
+            },
+            "children": []
+        },
         {  
             "id": "MockFilter1",  
             "name": "模拟过滤器",  

test/experiments/mock_protocol/addteststation.json

@@ -4,58 +4,83 @@
             "id": "AddTestStation",
             "name": "添加试剂测试工作站",
             "children": [
-                "pump_add",
-                "flask_1",
-                "flask_2", 
-                "flask_3",
-                "flask_4",
-                "reactor",
+                "transfer_pump",
+                "multiway_valve", 
                 "stirrer",
-                "flask_air"
+                "flask_reagent1",
+                "flask_reagent2",
+                "flask_reagent3",
+                "flask_reagent4",
+                "reactor",
+                "flask_waste",
+                "flask_rinsing",
+                "flask_buffer"
             ],
             "parent": null,
             "type": "device",
             "class": "workstation",
             "position": {
-                "x": 620.6111111111111,
+                "x": 620,
                 "y": 171,
                 "z": 0
             },
             "config": {
-                "protocol_type": ["AddProtocol", "PumpTransferProtocol", "CleanProtocol"]
+                "protocol_type": ["AddProtocol", "TransferProtocol", "StartStirProtocol", "StopStirProtocol"]
             },
             "data": {}
         },
         {
-            "id": "pump_add",
-            "name": "pump_add",
+            "id": "transfer_pump",
+            "name": "注射器泵",
             "children": [],
             "parent": "AddTestStation",
             "type": "device",
-            "class": "virtual_pump",
+            "class": "virtual_transfer_pump",
             "position": {
-                "x": 520.6111111111111,
+                "x": 520,
                 "y": 300,
                 "z": 0
             },
             "config": {
                 "port": "VIRTUAL",
-                "max_volume": 25.0
+                "max_volume": 50.0,
+                "transfer_rate": 5.0
             },
             "data": {
                 "status": "Idle"
             }
         },
+        {
+            "id": "multiway_valve",
+            "name": "八通阀门",
+            "children": [],
+            "parent": "AddTestStation",
+            "type": "device",
+            "class": "virtual_multiway_valve",
+            "position": {
+                "x": 420,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "port": "VIRTUAL",
+                "positions": 8
+            },
+            "data": {
+                "status": "Idle",
+                "current_position": 1
+            }
+        },
         {
             "id": "stirrer",
-            "name": "stirrer",
+            "name": "搅拌器",
             "children": [],
             "parent": "AddTestStation",
             "type": "device",
             "class": "virtual_stirrer",
             "position": {
-                "x": 698.1111111111111,
-                "y": 478,
+                "x": 720,
+                "y": 450,
                 "z": 0
             },
             "config": {
@@ -68,110 +93,115 @@
             }
         },
         {
-            "id": "flask_1",
-            "name": "通用试剂瓶1",
+            "id": "flask_reagent1",
+            "name": "试剂瓶1 (甲醇)",
             "children": [],
             "parent": "AddTestStation",
             "type": "container",
             "class": null,
             "position": {
                 "x": 100,
-                "y": 428,
+                "y": 400,
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 1000.0
             },
             "data": {
-                "liquid": []
+                "liquid": [
+                    {
+                        "name": "甲醇",
+                        "volume": 800.0,
+                        "concentration": "99.9%"
+                    }
+                ]
             }
         },
         {
-            "id": "flask_2",
-            "name": "通用试剂瓶2",
+            "id": "flask_reagent2",
+            "name": "试剂瓶2 (乙醇)",
             "children": [],
             "parent": "AddTestStation",
             "type": "container",
             "class": null,
             "position": {
-                "x": 250,
-                "y": 428,
+                "x": 180,
+                "y": 400,
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 1000.0
             },
             "data": {
-                "liquid": []
+                "liquid": [
+                    {
+                        "name": "乙醇",
+                        "volume": 750.0,
+                        "concentration": "95%"
+                    }
+                ]
             }
         },
         {
-            "id": "flask_3",
-            "name": "通用试剂瓶3",
+            "id": "flask_reagent3",
+            "name": "试剂瓶3 (丙酮)",
             "children": [],
             "parent": "AddTestStation",
             "type": "container",
             "class": null,
             "position": {
-                "x": 400,
-                "y": 428,
+                "x": 260,
+                "y": 400,
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 1000.0
             },
             "data": {
-                "liquid": []
+                "liquid": [
+                    {
+                        "name": "丙酮",
+                        "volume": 900.0,
+                        "concentration": "99.5%"
+                    }
+                ]
             }
         },
         {
-            "id": "flask_4",
-            "name": "通用试剂瓶4",
+            "id": "flask_reagent4",
+            "name": "试剂瓶4 (二氯甲烷)",
             "children": [],
             "parent": "AddTestStation",
             "type": "container",
             "class": null,
             "position": {
-                "x": 550,
-                "y": 428,
+                "x": 340,
+                "y": 400,
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 1000.0
             },
             "data": {
-                "liquid": []
+                "liquid": [
+                    {
+                        "name": "二氯甲烷",
+                        "volume": 850.0,
+                        "concentration": "99.8%"
+                    }
+                ]
             }
         },
         {
             "id": "reactor",
-            "name": "reactor",
+            "name": "反应器",
             "children": [],
             "parent": "AddTestStation",
             "type": "container",
             "class": null,
             "position": {
-                "x": 698.1111111111111,
-                "y": 428,
-                "z": 0
-            },
-            "config": {
-                "max_volume": 5000.0
-            },
-            "data": {
-                "liquid": []
-            }
-        },
-        {
-            "id": "flask_air",
-            "name": "flask_air",
-            "children": [],
-            "parent": "AddTestStation",
-            "type": "container",
-            "class": null,
-            "position": {
-                "x": 800,
-                "y": 300,
+                "x": 720,
+                "y": 400,
                 "z": 0
             },
             "config": {
@@ -180,70 +210,166 @@
             "data": {
                 "liquid": []
             }
+        },
+        {
+            "id": "flask_waste",
+            "name": "废液瓶",
+            "children": [],
+            "parent": "AddTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 850,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 3000.0
+            },
+            "data": {
+                "liquid": []
+            }
+        },
+        {
+            "id": "flask_rinsing",
+            "name": "冲洗液瓶",
+            "children": [],
+            "parent": "AddTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 950,
+                "y": 300,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "去离子水",
+                        "volume": 800.0,
+                        "concentration": "纯净"
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_buffer",
+            "name": "缓冲液瓶",
+            "children": [],
+            "parent": "AddTestStation",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 950,
+                "y": 400,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 1000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "name": "磷酸盐缓冲液",
+                        "volume": 700.0,
+                        "concentration": "0.1M, pH 7.4"
+                    }
+                ]
+            }
         }
     ],
     "links": [
         {
-            "source": "stirrer",
+            "source": "transfer_pump",
+            "target": "multiway_valve",
+            "type": "physical",
+            "port": {
+                "transfer_pump": "syringe-port",
+                "multiway_valve": "multiway-valve-inlet"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_reagent1",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-1",
+                "flask_reagent1": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_reagent2",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-2",
+                "flask_reagent2": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_reagent3",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-3",
+                "flask_reagent3": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_reagent4",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-4",
+                "flask_reagent4": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
             "target": "reactor",
             "type": "physical",
             "port": {
-                "stirrer": "top",
-                "reactor": "bottom"
-            }
-        },
-        {
-            "source": "pump_add",
-            "target": "flask_1",
-            "type": "physical",
-            "port": {
-                "pump_add": "outlet",
-                "flask_1": "top"
-            }
-        },
-        {
-            "source": "pump_add",
-            "target": "flask_2",
-            "type": "physical",
-            "port": {
-                "pump_add": "inlet",
-                "flask_2": "top"
-            }
-        },
-        {
-            "source": "pump_add",
-            "target": "flask_3",
-            "type": "physical",
-            "port": {
-                "pump_add": "inlet",
-                "flask_3": "top"
-            }
-        },
-        {
-            "source": "pump_add",
-            "target": "flask_4",
-            "type": "physical",
-            "port": {
-                "pump_add": "inlet",
-                "flask_4": "top"
-            }
-        },
-        {
-            "source": "pump_add",
-            "target": "reactor",
-            "type": "physical",
-            "port": {
-                "pump_add": "outlet",
+                "multiway_valve": "multiway-valve-port-5",
                 "reactor": "top"
             }
         },
         {
-            "source": "pump_add",
-            "target": "flask_air",
+            "source": "multiway_valve",
+            "target": "flask_waste",
             "type": "physical",
             "port": {
-                "pump_add": "inlet",
-                "flask_air": "top"
+                "multiway_valve": "multiway-valve-port-6",
+                "flask_waste": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_rinsing",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-7",
+                "flask_rinsing": "top"
+            }
+        },
+        {
+            "source": "multiway_valve",
+            "target": "flask_buffer",
+            "type": "physical",
+            "port": {
+                "multiway_valve": "multiway-valve-port-8",
+                "flask_buffer": "top"
+            }
+        },
+        {
+            "source": "stirrer",
+            "target": "reactor",
+            "type": "physical",
+            "port": {
+                "stirrer": "stirrer-vessel",
+                "reactor": "bottom"
             }
         }
     ]

test/experiments/mock_reactor.json

@@ -14,8 +14,8 @@
             "type": "device",
             "class": "workstation",
             "position": {
-                "x": 620.6111111111111,
-                "y": 171,
+                "x": 0,
+                "y": 0,
                 "z": 0
             },
             "config": {
@@ -30,14 +30,17 @@
             "children": [],
             "parent": "ReactorX",
             "type": "container",
-            "class": null,
+            "class": "container",
             "position": {
                 "x": 698.1111111111111,
                 "y": 428,
                 "z": 0
             },
             "config": {
-                "max_volume": 5000.0
+                "max_volume": 5000.0,
+                "size_x": 200.0,
+                "size_y": 200.0,
+                "size_z": 200.0
             },
             "data": {
                 "liquid": [
@@ -71,7 +74,7 @@
             "type": "device",
             "class": "solenoid_valve.mock",
             "position": {
-                "x": 620.6111111111111,
+                "x": 780,
                 "y": 171,
                 "z": 0
             },
@@ -89,7 +92,7 @@
             "type": "device",
             "class": "vacuum_pump.mock",
             "position": {
-                "x": 620.6111111111111,
+                "x": 500,
                 "y": 171,
                 "z": 0
             },
@@ -107,7 +110,7 @@
             "type": "device",
             "class": "gas_source.mock",
             "position": {
-                "x": 620.6111111111111,
+                "x": 900,
                 "y": 171,
                 "z": 0
             },
@@ -119,39 +122,39 @@
     ],
     "links": [
         {
-            "source": "reactor",
-            "target": "vacuum_valve",
-            "type": "physical",
+            "source": "vacuum_valve",
+            "target": "reactor",
+            "type": "fluid",
             "port": {
                 "reactor": "top",
-                "vacuum_valve": "1"
+                "vacuum_valve": "out"
             }
         },
         {
-            "source": "reactor",
-            "target": "gas_valve",
-            "type": "physical",
+            "source": "gas_valve",
+            "target": "reactor",
+            "type": "fluid",
             "port": {
                 "reactor": "top",
-                "gas_valve": "1"
+                "gas_valve": "out"
             }
         },
         {
             "source": "vacuum_pump",
             "target": "vacuum_valve",
-            "type": "physical",
+            "type": "fluid",
             "port": {
                 "vacuum_pump": "out",
-                "vacuum_valve": "0"
+                "vacuum_valve": "in"
             }
         },
         {
             "source": "gas_source",
             "target": "gas_valve",
-            "type": "physical",
+            "type": "fluid",
             "port": {
                 "gas_source": "out",
-                "gas_valve": "0"
+                "gas_valve": "in"
             }
         }
     ]

test/experiments/plr_test_converted.json

@@ -1,8 +1,8 @@
 {
     "nodes": [
         {
-            "id": "PLR_STATION",
-            "name": "PLR_LH_TEST",
+            "id": "liquid_handler",
+            "name": "liquid_handler",
             "parent": null,
             "type": "device",
             "class": "liquid_handler",
@@ -37,7 +37,7 @@
                 "tip_rack",
                 "plate_well"
             ],
-            "parent": "PLR_STATION",
+            "parent": "liquid_handler",
             "type": "deck",
             "class": "OTDeck",
             "position": {
@@ -9650,7 +9650,7 @@
             "children": [],
             "parent": null,
             "type": "device",
-            "class": "moveit.arm_slider",
+            "class": "robotic_arm.SCARA_with_slider.virtual",
             "position": {
                 "x": -500,
                 "y": 1000,

test/experiments/reaction_station_bioyond.json

@@ -0,0 +1,69 @@
+{
+    "nodes": [
+        {
+            "id": "reaction_station_bioyond",
+            "name": "reaction_station_bioyond",
+            "parent": null,
+            "children": [
+                "Bioyond_Deck"
+            ],
+            "type": "device",
+            "class": "reaction_station.bioyond",
+            "config": {
+                "bioyond_config": {
+                    "api_key": "DE9BDDA0",
+                    "api_host": "http://192.168.1.200:44402",
+                    "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)": "3a160824-0665-01ed-285a-51ef817a9046",
+                        "Liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
+                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
+                    },
+                    "material_type_mappings": {
+                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
+                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
+                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
+                    }
+                },
+                "deck": {
+                    "data": {
+                        "_resource_child_name": "Bioyond_Deck",
+                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
+                    }
+                },
+                "protocol_type": []
+            },
+            "data": {}
+        },
+        {
+            "id": "Bioyond_Deck",
+            "name": "Bioyond_Deck",
+            "sample_id": null,
+            "children": [
+            ],
+            "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": {}
+        }
+    ]
+}

test/experiments/reaction_station_bioyond_test.json

@@ -0,0 +1,69 @@
+{
+    "nodes": [
+        {
+            "id": "reaction_station_bioyond",
+            "name": "reaction_station_bioyond",
+            "parent": null,
+            "children": [
+                "Bioyond_Deck"
+            ],
+            "type": "device",
+            "class": "workstation.bioyond",
+            "config": {
+                "bioyond_config": {
+                    "api_key": "DE9BDDA0",
+                    "api_host": "http://192.168.1.200:44388",
+                    "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)": "3a160824-0665-01ed-285a-51ef817a9046",
+                        "Liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
+                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
+                    },
+                    "material_type_mappings": {
+                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
+                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
+                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
+                    }
+                },
+                "deck": {
+                    "data": {
+                        "_resource_child_name": "Bioyond_Deck",
+                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
+                    }
+                },
+                "protocol_type": []
+            },
+            "data": {}
+        },
+        {
+            "id": "Bioyond_Deck",
+            "name": "Bioyond_Deck",
+            "sample_id": null,
+            "children": [
+            ],
+            "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": {}
+        }
+    ]
+}

test/experiments/test_moveit.json

@@ -1,32 +1,48 @@
 {
     "nodes": [
 
+
         {
-            "id": "benyao",
-            "name": "benyao",
-            "children": [
-            ],
+            "id": "arm_slider",
+            "name": "arm_slider",
+            "children": [],
             "parent": null,
             "type": "device",
-            "class": "moveit.arm_slider",
+            "class": "robotic_arm.SCARA_with_slider.virtual",
             "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
+                "x": -500,
+                "y": 1000,
+                "z": -100
             },
             "config": {
                 "moveit_type": "arm_slider",
                 "joint_poses": {
                     "arm": {
-                        "home": [0.0, 0.2, 0.0, 0.0, 0.0],
-                        "pick": [1.2, 0.0, 0.0, 0.0, 0.0]
+                        "hotel_1": [
+                            1.05,
+                            0.568,
+                            -1.0821,
+                            0.0,
+                            1.0821
+                        ],
+                        "home": [
+                            0.865,
+                            0.09,
+                            0.8727,
+                            0.0,
+                            -0.8727
+                        ]
                     }
                 },
-                "device_config": {
-                }
+                "rotation": {
+                    "x": 0,
+                    "y": 0,
+                    "z": -1.5708,
+                    "type": "Rotation"
+                },
+                "device_config": {}
             },
-            "data": {
-            }
+            "data": {}
         }
     ],
     "links": [

test/experiments/workshop.json

@@ -0,0 +1,949 @@
+{
+    "nodes": [
+        {
+            "id": "simple_station",
+            "name": "愚公常量合成工作站",
+            "children": [
+                "serial_pump",
+                "pump_reagents",
+                "pump_workup",
+                "flask_CH2Cl2",
+                "waste_workup",
+                "separator_controller",
+                "flask_separator",
+                "flask_air"
+            ],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 620.6111111111111,
+                "y": 171,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["PumpTransferProtocol", "CleanProtocol", "SeparateProtocol", "EvaporateProtocol"]
+            },
+            "data": {
+            }
+        },
+        {
+            "id": "serial_pump",
+            "name": "serial_pump",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "serial",
+            "position": {
+                "x": 620.6111111111111,
+                "y": 171,
+                "z": 0
+            },
+            "config": {
+                "port": "COM7",
+                "baudrate": 9600
+            },
+            "data": {
+            }
+        },
+        {
+            "id": "pump_reagents",
+            "name": "pump_reagents",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "syringepump.runze",
+            "position": {
+                "x": 620.6111111111111,
+                "y": 171,
+                "z": 0
+            },
+            "config": {
+                "port": "/devices/PumpBackbone/Serial/serialwrite",
+                "address": "1",
+                "max_volume": 25.0
+            },
+            "data": {
+                "max_velocity": 1.0,
+                "position": 0.0,
+                "status": "Idle",
+                "valve_position": "0"
+            }
+        },
+        {
+            "id": "flask_CH2Cl2",
+            "name": "flask_CH2Cl2",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 430.4087301587302,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "CH2Cl2",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_acetone",
+            "name": "flask_acetone",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 295.36944444444447,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "acetone",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_NH4Cl",
+            "name": "flask_NH4Cl",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 165.36944444444444,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "NH4Cl",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_grignard",
+            "name": "flask_grignard",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 165.36944444444444,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "grignard",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_THF",
+            "name": "flask_THF",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 35,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "THF",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "reactor",
+            "name": "reactor",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 698.1111111111111,
+                "y": 428,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 5000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "stirrer",
+            "name": "stirrer",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "heaterstirrer.dalong",
+            "position": {
+                "x": 698.1111111111111,
+                "y": 478,
+                "z": 0
+            },
+            "config": {
+                "port": "COM43",
+                "temp_warning": 60.0
+            },
+            "data": {
+                "status": "Idle",
+                "temp": 0.0,
+                "stir_speed": 0.0
+            }
+        },
+        {
+            "id": "pump_workup",
+            "name": "pump_workup",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "syringepump.runze",
+            "position": {
+                "x": 1195.611507936508,
+                "y": 686,
+                "z": 0
+            },
+            "config": {
+                "port": "/devices/PumpBackbone/Serial/serialwrite",
+                "address": "2",
+                "max_volume": 25.0
+            },
+            "data": {
+                "max_velocity": 1.0,
+                "position": 0.0,
+                "status": "Idle",
+                "valve_position": "0"
+            }
+        },
+        {
+            "id": "waste_workup",
+            "name": "waste_workup",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1587.703373015873,
+                "y": 1172.5,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "separator_controller",
+            "name": "separator_controller",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "separator.homemade",
+            "position": {
+                "x": 1624.4027777777778,
+                "y": 665.5,
+                "z": 0
+            },
+            "config": {
+                "port_executor": "/dev/tty.usbserial-11140",
+                "port_sensor": "/dev/tty.usbserial-11130"
+            },
+            "data": {
+                "sensordata": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "flask_separator",
+            "name": "flask_separator",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1614.404365079365,
+                "y": 948,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "flask_holding",
+            "name": "flask_holding",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1915.7035714285714,
+                "y": 665.5,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "flask_H2O",
+            "name": "flask_H2O",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1785.7035714285714,
+                "y": 665.5,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "H2O",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "flask_NaHCO3",
+            "name": "flask_NaHCO3",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 2054.0650793650793,
+                "y": 665.5,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                    {
+                        "liquid_type": "NaHCO3",
+                        "liquid_volume": 1500.0
+                    }
+                ]
+            }
+        },
+        {
+            "id": "pump_column",
+            "name": "pump_column",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "syringepump.runze",
+            "position": {
+                "x": 1630.6527777777778,
+                "y": 448.5,
+                "z": 0
+            },
+            "config": {
+                "port": "/devices/PumpBackbone/Serial/serialwrite",
+                "address": "3",
+                "max_volume": 25.0
+            },
+            "data": {
+                "max_velocity": 1.0,
+                "position": 0.0,
+                "status": "Idle",
+                "valve_position": "0"
+            }
+        },
+        {
+            "id": "rotavap",
+            "name": "rotavap",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "rotavap",
+            "position": {
+                "x": 1339.7031746031746,
+                "y": 968.5,
+                "z": 0
+            },
+            "config": {
+                "port": "COM15"
+            },
+            "data": {
+                "temperature": 0.0,
+                "rotate_time": 0.0,
+                "status": "Idle"
+            }
+        },
+        {
+            "id": "flask_rv",
+            "name": "flask_rv",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1339.7031746031746,
+                "y": 1152,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "column",
+            "name": "column",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 909.722619047619,
+                "y": 948,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 200.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "flask_column",
+            "name": "flask_column",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 867.972619047619,
+                "y": 1152,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "flask_air",
+            "name": "flask_air",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 742.722619047619,
+                "y": 948,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "dry_column",
+            "name": "dry_column",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1206.722619047619,
+                "y": 948,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 200.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "flask_dry_column",
+            "name": "flask_dry_column",
+            "children": [],
+            "parent": "simple_station",
+            "type": "container",
+            "class": null,
+            "position": {
+                "x": 1148.222619047619,
+                "y": 1152,
+                "z": 0
+            },
+            "config": {
+                "max_volume": 2000.0
+            },
+            "data": {
+                "liquid": [
+                ]
+            }
+        },
+        {
+            "id": "pump_ext",
+            "name": "pump_ext",
+            "children": [],
+            "parent": "simple_station",
+            "type": "device",
+            "class": "syringepump.runze",
+            "position": {
+                "x": 1469.7031746031746,
+                "y": 968.5,
+                "z": 0
+            },
+            "config": {
+                "port": "/devices/PumpBackbone/Serial/serialwrite",
+                "address": "4",
+                "max_volume": 25.0
+            },
+            "data": {
+                "max_velocity": 1.0,
+                "position": 0.0,
+                "status": "Idle",
+                "valve_position": "0"
+            }
+        },
+        {
+            "id": "AGV",
+            "name": "AGV",
+            "children": ["zhixing_agv", "zhixing_ur_arm"],
+            "parent": null,
+            "type": "device",
+            "class": "workstation",
+            "position": {
+                "x": 698.1111111111111,
+                "y": 478,
+                "z": 0
+            },
+            "config": {
+                "protocol_type": ["AGVTransferProtocol"]
+            },
+            "data": {
+            }
+        },
+        {
+            "id": "zhixing_agv",
+            "name": "zhixing_agv",
+            "children": [],
+            "parent": "AGV",
+            "type": "device",
+            "class": "zhixing_agv",
+            "position": {
+                "x": 698.1111111111111,
+                "y": 478,
+                "z": 0
+            },
+            "config": {
+                "host": "192.168.1.42"
+            },
+            "data": {
+            }
+        },
+        {
+            "id": "zhixing_ur_arm",
+            "name": "zhixing_ur_arm",
+            "children": [],
+            "parent": "AGV",
+            "type": "device",
+            "class": "zhixing_ur_arm",
+            "position": {
+                "x": 698.1111111111111,
+                "y": 478,
+                "z": 0
+            },
+            "config": {
+                "host": "192.168.1.178"
+            },
+            "data": {
+            }
+        }
+    ],
+    "links": [
+        {
+            "source": "pump_reagents",
+            "target": "serial_pump",
+            "type": "communication",
+            "port": {
+                "pump_reagents": "port",
+                "serial_pump": "port"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "serial_pump",
+            "type": "communication",
+            "port": {
+                "pump_reagents": "port",
+                "serial_pump": "port"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "serial_pump",
+            "type": "communication",
+            "port": {
+                "pump_reagents": "port",
+                "serial_pump": "port"
+            }
+        },
+        {
+            "source": "pump_ext",
+            "target": "serial_pump",
+            "type": "communication",
+            "port": {
+                "pump_reagents": "port",
+                "serial_pump": "port"
+            }
+        },
+        {
+            "source": "reactor",
+            "target": "pump_reagents",
+            "type": "physical",
+            "port": {
+                "reactor": "top",
+                "pump_reagents": "5"
+            }
+        },
+        {
+            "source": "rotavap",
+            "target": "flask_rv",
+            "type": "physical",
+            "port": {
+                "rotavap": "bottom",
+                "flask_rv": "top"
+            }
+        },
+        {
+            "source": "separator_controller",
+            "target": "flask_separator",
+            "type": "physical",
+            "port": {
+                "separator_controller": "bottom",
+                "flask_separator": "top"
+            }
+        },
+        {
+            "source": "column",
+            "target": "flask_column",
+            "type": "physical",
+            "port": {
+                "column": "bottom",
+                "flask_column": "top"
+            }
+        },
+        {
+            "source": "dry_column",
+            "target": "flask_dry_column",
+            "type": "physical",
+            "port": {
+                "dry_column": "bottom",
+                "flask_dry_column": "top"
+            }
+        },
+        {
+            "source": "pump_ext",
+            "target": "pump_column",
+            "type": "physical",
+            "port": {
+                "pump_ext": "8",
+                "pump_column": "1"
+            }
+        },
+        {
+            "source": "pump_ext",
+            "target": "waste_workup",
+            "type": "physical",
+            "port": {
+                "pump_ext": "2",
+                "waste_workup": "-1"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_THF",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "7",
+                "flask_THF": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_NH4Cl",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "4",
+                "flask_NH4Cl": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_CH2Cl2",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "2",
+                "flask_CH2Cl2": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_acetone",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "3",
+                "flask_acetone": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "pump_workup",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "1",
+                "pump_workup": "8"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_grignard",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "6",
+                "flask_grignard": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "reactor",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "5",
+                "reactor": "top"
+            }
+        },
+        {
+            "source": "pump_reagents",
+            "target": "flask_air",
+            "type": "physical",
+            "port": {
+                "pump_reagents": "8",
+                "flask_air": "-1"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "waste_workup",
+            "type": "physical",
+            "port": {
+                "pump_workup": "2",
+                "waste_workup": "-1"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "flask_H2O",
+            "type": "physical",
+            "port": {
+                "pump_workup": "7",
+                "flask_H2O": "top"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "flask_NaHCO3",
+            "type": "physical",
+            "port": {
+                "pump_workup": "6",
+                "flask_NaHCO3": "top"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "pump_reagents",
+            "type": "physical",
+            "port": {
+                "pump_workup": "8",
+                "pump_reagents": "1"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "flask_holding",
+            "type": "physical",
+            "port": {
+                "pump_workup": "5",
+                "flask_holding": "top"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "separator_controller",
+            "type": "physical",
+            "port": {
+                "pump_workup": "4",
+                "separator_controller": "top"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "flask_separator",
+            "type": "physical",
+            "port": {
+                "pump_workup": "3",
+                "flask_separator": "top"
+            }
+        },
+        {
+            "source": "pump_workup",
+            "target": "pump_column",
+            "type": "physical",
+            "port": {
+                "pump_workup": "1",
+                "pump_column": "8"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "column",
+            "type": "physical",
+            "port": {
+                "pump_column": "4",
+                "column": "top"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "flask_column",
+            "type": "physical",
+            "port": {
+                "pump_column": "3",
+                "flask_column": "top"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "rotavap",
+            "type": "physical",
+            "port": {
+                "pump_column": "2",
+                "rotavap": "-1"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "pump_workup",
+            "type": "physical",
+            "port": {
+                "pump_column": "8",
+                "pump_workup": "1"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "flask_air",
+            "type": "physical",
+            "port": {
+                "pump_column": "5",
+                "flask_air": "-1"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "dry_column",
+            "type": "physical",
+            "port": {
+                "pump_column": "7",
+                "dry_column": "top"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "flask_dry_column",
+            "type": "physical",
+            "port": {
+                "pump_column": "6",
+                "flask_dry_column": "top"
+            }
+        },
+        {
+            "source": "pump_column",
+            "target": "pump_ext",
+            "type": "physical",
+            "port": {
+                "pump_column": "1",
+                "pump_ext": "8"
+            }
+        }
+    ]
+}

test/registry/example_devices.py

@@ -0,0 +1,588 @@
+"""
+示例设备类文件，用于测试注册表编辑器
+"""
+
+import asyncio
+from typing import Dict, Any, Optional, List
+
+
+class SmartPumpController:
+    """
+    智能泵控制器
+
+    支持多种泵送模式，具有高精度流量控制和自动校准功能。
+    适用于实验室自动化系统中的液体处理任务。
+    """
+
+    def __init__(self, device_id: str = "smart_pump_01", port: str = "/dev/ttyUSB0"):
+        """
+        初始化智能泵控制器
+
+        Args:
+            device_id: 设备唯一标识符
+            port: 通信端口
+        """
+        self.device_id = device_id
+        self.port = port
+        self.is_connected = False
+        self.current_flow_rate = 0.0
+        self.total_volume_pumped = 0.0
+        self.calibration_factor = 1.0
+        self.pump_mode = "continuous"  # continuous, volume, rate
+
+    def connect_device(self, timeout: int = 10) -> bool:
+        """
+        连接到泵设备
+
+        Args:
+            timeout: 连接超时时间（秒）
+
+        Returns:
+            bool: 连接是否成功
+        """
+        # 模拟连接过程
+        self.is_connected = True
+        return True
+
+    def disconnect_device(self) -> bool:
+        """
+        断开设备连接
+
+        Returns:
+            bool: 断开连接是否成功
+        """
+        self.is_connected = False
+        self.current_flow_rate = 0.0
+        return True
+
+    def set_flow_rate(self, flow_rate: float, units: str = "ml/min") -> bool:
+        """
+        设置泵流速
+
+        Args:
+            flow_rate: 流速值
+            units: 流速单位
+
+        Returns:
+            bool: 设置是否成功
+        """
+        if not self.is_connected:
+            return False
+
+        self.current_flow_rate = flow_rate
+        return True
+
+    async def pump_volume_async(self, volume: float, flow_rate: float) -> Dict[str, Any]:
+        """
+        异步泵送指定体积的液体
+
+        Args:
+            volume: 目标体积 (mL)
+            flow_rate: 泵送流速 (mL/min)
+
+        Returns:
+            Dict: 包含操作结果的字典
+        """
+        if not self.is_connected:
+            return {"success": False, "error": "设备未连接"}
+
+        # 计算泵送时间
+        pump_time = (volume / flow_rate) * 60  # 转换为秒
+
+        self.current_flow_rate = flow_rate
+        await asyncio.sleep(min(pump_time, 3.0))  # 模拟泵送过程
+
+        self.total_volume_pumped += volume
+        self.current_flow_rate = 0.0
+
+        return {
+            "success": True,
+            "pumped_volume": volume,
+            "actual_time": min(pump_time, 3.0),
+            "total_volume": self.total_volume_pumped,
+        }
+
+    def emergency_stop(self) -> bool:
+        """
+        紧急停止泵
+
+        Returns:
+            bool: 停止是否成功
+        """
+        self.current_flow_rate = 0.0
+        return True
+
+    def perform_calibration(self, reference_volume: float, measured_volume: float) -> bool:
+        """
+        执行泵校准
+
+        Args:
+            reference_volume: 参考体积
+            measured_volume: 实际测量体积
+
+        Returns:
+            bool: 校准是否成功
+        """
+        if measured_volume > 0:
+            self.calibration_factor = reference_volume / measured_volume
+            return True
+        return False
+
+    # 状态查询方法
+    def get_connection_status(self) -> str:
+        """获取连接状态"""
+        return "connected" if self.is_connected else "disconnected"
+
+    def get_current_flow_rate(self) -> float:
+        """获取当前流速 (mL/min)"""
+        return self.current_flow_rate
+
+    def get_total_volume(self) -> float:
+        """获取累计泵送体积 (mL)"""
+        return self.total_volume_pumped
+
+    def get_calibration_factor(self) -> float:
+        """获取校准因子"""
+        return self.calibration_factor
+
+    def get_pump_mode(self) -> str:
+        """获取泵送模式"""
+        return self.pump_mode
+
+    def get_device_status(self) -> Dict[str, Any]:
+        """获取设备完整状态信息"""
+        return {
+            "device_id": self.device_id,
+            "connected": self.is_connected,
+            "flow_rate": self.current_flow_rate,
+            "total_volume": self.total_volume_pumped,
+            "calibration_factor": self.calibration_factor,
+            "mode": self.pump_mode,
+            "running": self.current_flow_rate > 0,
+        }
+
+
+class AdvancedTemperatureController:
+    """
+    高级温度控制器
+
+    支持PID控制、多点温度监控和程序化温度曲线。
+    适用于需要精确温度控制的化学反应和材料处理过程。
+    """
+
+    def __init__(self, controller_id: str = "temp_controller_01"):
+        """
+        初始化温度控制器
+
+        Args:
+            controller_id: 控制器ID
+        """
+        self.controller_id = controller_id
+        self.current_temperature = 25.0
+        self.target_temperature = 25.0
+        self.is_heating = False
+        self.is_cooling = False
+        self.pid_enabled = True
+        self.temperature_history: List[Dict] = []
+
+    def set_target_temperature(self, temperature: float, rate: float = 10.0) -> bool:
+        """
+        设置目标温度
+
+        Args:
+            temperature: 目标温度 (°C)
+            rate: 升温/降温速率 (°C/min)
+
+        Returns:
+            bool: 设置是否成功
+        """
+        self.target_temperature = temperature
+        return True
+
+    async def heat_to_temperature_async(
+        self, temperature: float, tolerance: float = 0.5, timeout: int = 600
+    ) -> Dict[str, Any]:
+        """
+        异步加热到指定温度
+
+        Args:
+            temperature: 目标温度 (°C)
+            tolerance: 温度容差 (°C)
+            timeout: 最大等待时间 (秒)
+
+        Returns:
+            Dict: 操作结果
+        """
+        self.target_temperature = temperature
+        start_temp = self.current_temperature
+
+        if temperature > start_temp:
+            self.is_heating = True
+        elif temperature < start_temp:
+            self.is_cooling = True
+
+        # 模拟温度变化过程
+        steps = min(abs(temperature - start_temp) * 2, 20)  # 计算步数
+        step_time = min(timeout / steps if steps > 0 else 1, 2.0)  # 每步最多2秒
+
+        for step in range(int(steps)):
+            progress = (step + 1) / steps
+            self.current_temperature = start_temp + (temperature - start_temp) * progress
+
+            # 记录温度历史
+            self.temperature_history.append(
+                {
+                    "timestamp": asyncio.get_event_loop().time(),
+                    "temperature": self.current_temperature,
+                    "target": self.target_temperature,
+                }
+            )
+
+            await asyncio.sleep(step_time)
+
+            # 保持历史记录不超过100条
+            if len(self.temperature_history) > 100:
+                self.temperature_history.pop(0)
+
+        # 最终设置为目标温度
+        self.current_temperature = temperature
+        self.is_heating = False
+        self.is_cooling = False
+
+        return {
+            "success": True,
+            "final_temperature": self.current_temperature,
+            "start_temperature": start_temp,
+            "time_taken": steps * step_time,
+        }
+
+    def enable_pid_control(self, kp: float = 1.0, ki: float = 0.1, kd: float = 0.05) -> bool:
+        """
+        启用PID控制
+
+        Args:
+            kp: 比例增益
+            ki: 积分增益
+            kd: 微分增益
+
+        Returns:
+            bool: 启用是否成功
+        """
+        self.pid_enabled = True
+        return True
+
+    def run_temperature_program(self, program: List[Dict]) -> bool:
+        """
+        运行温度程序
+
+        Args:
+            program: 温度程序列表，每个元素包含温度和持续时间
+
+        Returns:
+            bool: 程序启动是否成功
+        """
+        # 模拟程序启动
+        return True
+
+    # 状态查询方法
+    def get_current_temperature(self) -> float:
+        """获取当前温度 (°C)"""
+        return round(self.current_temperature, 2)
+
+    def get_target_temperature(self) -> float:
+        """获取目标温度 (°C)"""
+        return self.target_temperature
+
+    def get_heating_status(self) -> bool:
+        """获取加热状态"""
+        return self.is_heating
+
+    def get_cooling_status(self) -> bool:
+        """获取制冷状态"""
+        return self.is_cooling
+
+    def get_pid_status(self) -> bool:
+        """获取PID控制状态"""
+        return self.pid_enabled
+
+    def get_temperature_history(self) -> List[Dict]:
+        """获取温度历史记录"""
+        return self.temperature_history[-10:]  # 返回最近10条记录
+
+    def get_controller_status(self) -> Dict[str, Any]:
+        """获取控制器完整状态"""
+        return {
+            "controller_id": self.controller_id,
+            "current_temp": self.current_temperature,
+            "target_temp": self.target_temperature,
+            "is_heating": self.is_heating,
+            "is_cooling": self.is_cooling,
+            "pid_enabled": self.pid_enabled,
+            "history_count": len(self.temperature_history),
+        }
+
+
+class MultiChannelAnalyzer:
+    """
+    多通道分析仪
+
+    支持同时监测多个通道的信号，提供实时数据采集和分析功能。
+    常用于光谱分析、电化学测量等应用场景。
+    """
+
+    def __init__(self, analyzer_id: str = "analyzer_01", channels: int = 8):
+        """
+        初始化多通道分析仪
+
+        Args:
+            analyzer_id: 分析仪ID
+            channels: 通道数量
+        """
+        self.analyzer_id = analyzer_id
+        self.channel_count = channels
+        self.channel_data = {i: {"value": 0.0, "unit": "V", "enabled": True} for i in range(channels)}
+        self.is_measuring = False
+        self.sample_rate = 1000  # Hz
+
+    def configure_channel(self, channel: int, enabled: bool = True, unit: str = "V") -> bool:
+        """
+        配置通道
+
+        Args:
+            channel: 通道编号
+            enabled: 是否启用
+            unit: 测量单位
+
+        Returns:
+            bool: 配置是否成功
+        """
+        if 0 <= channel < self.channel_count:
+            self.channel_data[channel]["enabled"] = enabled
+            self.channel_data[channel]["unit"] = unit
+            return True
+        return False
+
+    async def start_measurement_async(self, duration: int = 10) -> Dict[str, Any]:
+        """
+        开始异步测量
+
+        Args:
+            duration: 测量持续时间（秒）
+
+        Returns:
+            Dict: 测量结果
+        """
+        self.is_measuring = True
+
+        # 模拟数据采集
+        measurements = []
+        for second in range(duration):
+            timestamp = asyncio.get_event_loop().time()
+            frame_data = {}
+
+            for channel in range(self.channel_count):
+                if self.channel_data[channel]["enabled"]:
+                    # 模拟传感器数据
+                    import random
+
+                    value = random.uniform(-5.0, 5.0)
+                    frame_data[f"channel_{channel}"] = value
+                    self.channel_data[channel]["value"] = value
+
+            measurements.append({"timestamp": timestamp, "data": frame_data})
+
+            await asyncio.sleep(1.0)  # 每秒采集一次
+
+        self.is_measuring = False
+
+        return {
+            "success": True,
+            "duration": duration,
+            "samples_count": len(measurements),
+            "measurements": measurements[-5:],  # 只返回最后5个样本
+            "channels_active": len([ch for ch in self.channel_data.values() if ch["enabled"]]),
+        }
+
+    def stop_measurement(self) -> bool:
+        """
+        停止测量
+
+        Returns:
+            bool: 停止是否成功
+        """
+        self.is_measuring = False
+        return True
+
+    def reset_channels(self) -> bool:
+        """
+        重置所有通道
+
+        Returns:
+            bool: 重置是否成功
+        """
+        for channel in self.channel_data:
+            self.channel_data[channel]["value"] = 0.0
+        return True
+
+    # 状态查询方法
+    def get_measurement_status(self) -> bool:
+        """获取测量状态"""
+        return self.is_measuring
+
+    def get_channel_count(self) -> int:
+        """获取通道数量"""
+        return self.channel_count
+
+    def get_sample_rate(self) -> float:
+        """获取采样率 (Hz)"""
+        return self.sample_rate
+
+    def get_channel_values(self) -> Dict[int, float]:
+        """获取所有通道的当前值"""
+        return {ch: data["value"] for ch, data in self.channel_data.items() if data["enabled"]}
+
+    def get_enabled_channels(self) -> List[int]:
+        """获取已启用的通道列表"""
+        return [ch for ch, data in self.channel_data.items() if data["enabled"]]
+
+    def get_analyzer_status(self) -> Dict[str, Any]:
+        """获取分析仪完整状态"""
+        return {
+            "analyzer_id": self.analyzer_id,
+            "channel_count": self.channel_count,
+            "is_measuring": self.is_measuring,
+            "sample_rate": self.sample_rate,
+            "active_channels": len(self.get_enabled_channels()),
+            "channel_data": self.channel_data,
+        }
+
+
+class AutomatedDispenser:
+    """
+    自动分配器
+
+    精确控制固体和液体材料的分配，支持多种分配模式和容器管理。
+    集成称重功能，确保分配精度和重现性。
+    """
+
+    def __init__(self, dispenser_id: str = "dispenser_01"):
+        """
+        初始化自动分配器
+
+        Args:
+            dispenser_id: 分配器ID
+        """
+        self.dispenser_id = dispenser_id
+        self.is_ready = True
+        self.current_position = {"x": 0.0, "y": 0.0, "z": 0.0}
+        self.dispensed_total = 0.0
+        self.container_capacity = 1000.0  # mL
+        self.precision_mode = True
+
+    def move_to_position(self, x: float, y: float, z: float) -> bool:
+        """
+        移动到指定位置
+
+        Args:
+            x: X坐标 (mm)
+            y: Y坐标 (mm)
+            z: Z坐标 (mm)
+
+        Returns:
+            bool: 移动是否成功
+        """
+        self.current_position = {"x": x, "y": y, "z": z}
+        return True
+
+    async def dispense_liquid_async(self, volume: float, container_id: str, viscosity: str = "low") -> Dict[str, Any]:
+        """
+        异步分配液体
+
+        Args:
+            volume: 分配体积 (mL)
+            container_id: 容器ID
+            viscosity: 液体粘度等级
+
+        Returns:
+            Dict: 分配结果
+        """
+        if not self.is_ready:
+            return {"success": False, "error": "设备未就绪"}
+
+        if volume <= 0:
+            return {"success": False, "error": "体积必须大于0"}
+
+        # 模拟分配过程
+        dispense_time = volume * 0.1  # 每mL需要0.1秒
+        if viscosity == "high":
+            dispense_time *= 2  # 高粘度液体需要更长时间
+
+        await asyncio.sleep(min(dispense_time, 5.0))  # 最多等待5秒
+
+        self.dispensed_total += volume
+
+        return {
+            "success": True,
+            "dispensed_volume": volume,
+            "container_id": container_id,
+            "actual_time": min(dispense_time, 5.0),
+            "total_dispensed": self.dispensed_total,
+        }
+
+    def clean_dispenser(self, wash_volume: float = 5.0) -> bool:
+        """
+        清洗分配器
+
+        Args:
+            wash_volume: 清洗液体积 (mL)
+
+        Returns:
+            bool: 清洗是否成功
+        """
+        # 模拟清洗过程
+        return True
+
+    def calibrate_volume(self, target_volume: float) -> bool:
+        """
+        校准分配体积
+
+        Args:
+            target_volume: 校准目标体积 (mL)
+
+        Returns:
+            bool: 校准是否成功
+        """
+        # 模拟校准过程
+        return True
+
+    # 状态查询方法
+    def get_ready_status(self) -> bool:
+        """获取就绪状态"""
+        return self.is_ready
+
+    def get_current_position(self) -> Dict[str, float]:
+        """获取当前位置坐标"""
+        return self.current_position.copy()
+
+    def get_dispensed_total(self) -> float:
+        """获取累计分配体积 (mL)"""
+        return self.dispensed_total
+
+    def get_container_capacity(self) -> float:
+        """获取容器容量 (mL)"""
+        return self.container_capacity
+
+    def get_precision_mode(self) -> bool:
+        """获取精密模式状态"""
+        return self.precision_mode
+
+    def get_dispenser_status(self) -> Dict[str, Any]:
+        """获取分配器完整状态"""
+        return {
+            "dispenser_id": self.dispenser_id,
+            "ready": self.is_ready,
+            "position": self.current_position,
+            "dispensed_total": self.dispensed_total,
+            "capacity": self.container_capacity,
+            "precision_mode": self.precision_mode,
+        }

test/resources/bioyond_materials.json

@@ -0,0 +1,198 @@
+{
+    "data": [
+        {
+            "id": "3a1c67a9-aed7-b94d-9e24-bfdf10c8baa9",
+            "typeName": "烧杯",
+            "code": "0006-00160",
+            "barCode": "",
+            "name": "ODA",
+            "quantity": 120000.00000000000000000000000,
+            "lockQuantity": 695374.00000000000000000000000,
+            "unit": "微升",
+            "status": 1,
+            "isUse": false,
+            "locations": [
+                {
+                    "id": "3a14aa17-0d49-11d7-a6e1-f236b3e5e5a3",
+                    "whid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
+                    "whName": "堆栈1",
+                    "code": "0001-0001",
+                    "x": 1,
+                    "y": 1,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+            "detail": []
+        },
+        {
+            "id": "3a1c67a9-aed9-1ade-5fe1-cc04b24b171c",
+            "typeName": "烧杯",
+            "code": "0006-00161",
+            "barCode": "",
+            "name": "MPDA",
+            "quantity": 120000.00000000000000000000000,
+            "lockQuantity": 681618.00000000000000000000000,
+            "unit": "",
+            "status": 1,
+            "isUse": false,
+            "locations": [
+                {
+                    "id": "3a14aa17-0d49-4bc5-8836-517b75473f5f",
+                    "whid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
+                    "whName": "堆栈1",
+                    "code": "0001-0002",
+                    "x": 1,
+                    "y": 2,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+            "detail": []
+        },
+        {
+            "id": "3a1c67a9-aed9-2864-6783-2cee4e701ba6",
+            "typeName": "试剂瓶",
+            "code": "0004-00041",
+            "barCode": "",
+            "name": "NMP",
+            "quantity": 300000.00000000000000000000000,
+            "lockQuantity": 380000.00000000000000000000000,
+            "unit": "微升",
+            "status": 1,
+            "isUse": false,
+            "locations": [
+                {
+                    "id": "3a14aa3b-9fab-adac-7b9c-e1ee446b51d5",
+                    "whid": "3a14aa3b-9fab-9d8e-d1a7-828f01f51f0c",
+                    "whName": "站内试剂存放堆栈",
+                    "code": "0003-0001",
+                    "x": 1,
+                    "y": 1,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+            "detail": []
+        },
+        {
+            "id": "3a1c67a9-aed9-32c7-5809-3ba1b8db1aa1",
+            "typeName": "试剂瓶",
+            "code": "0004-00042",
+            "barCode": "",
+            "name": "PGME",
+            "quantity": 300000.00000000000000000000000,
+            "lockQuantity": 337892.00000000000000000000000,
+            "unit": "",
+            "status": 1,
+            "isUse": false,
+            "locations": [
+                {
+                    "id": "3a14aa3b-9fab-ca72-febc-b7c304476c78",
+                    "whid": "3a14aa3b-9fab-9d8e-d1a7-828f01f51f0c",
+                    "whName": "站内试剂存放堆栈",
+                    "code": "0003-0002",
+                    "x": 1,
+                    "y": 2,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+            "detail": []
+        },
+        {
+            "id": "3a1c68c8-0574-d748-725e-97a2e549f085",
+            "typeName": "样品板",
+            "code": "0001-00004",
+            "barCode": "",
+            "name": "0917",
+            "quantity": 1.0000000000000000000000000000,
+            "lockQuantity": 4.0000000000000000000000000000,
+            "unit": "块",
+            "status": 1,
+            "isUse": false,
+            "locations": [
+                {
+                    "id": "3a14aa17-0d49-f49c-6b66-b27f185a3b32",
+                    "whid": "3a14aa17-0d49-dce4-486e-4b5c85c8b366",
+                    "whName": "堆栈1",
+                    "code": "0001-0009",
+                    "x": 2,
+                    "y": 1,
+                    "z": 1,
+                    "quantity": 0
+                }
+            ],
+            "detail": [
+                {
+                    "id": "3a1c68c8-0574-69a1-9858-4637e0193451",
+                    "detailMaterialId": "3a1c68c8-0574-3630-bd42-bbf3623c5208",
+                    "code": null,
+                    "name": "SIDA",
+                    "quantity": "300000",
+                    "lockQuantity": "4",
+                    "unit": "微升",
+                    "x": 1,
+                    "y": 2,
+                    "z": 1,
+                    "associateId": null
+                },
+                {
+                    "id": "3a1c68c8-0574-8d51-3191-a31f5be421e5",
+                    "detailMaterialId": "3a1c68c8-0574-3b20-9ad7-90755f123d53",
+                    "code": null,
+                    "name": "BTDA-2",
+                    "quantity": "300000",
+                    "lockQuantity": "4",
+                    "unit": "微升",
+                    "x": 2,
+                    "y": 2,
+                    "z": 1,
+                    "associateId": null
+                },
+                {
+                    "id": "3a1c68c8-0574-da80-735b-53ae2197a360",
+                    "detailMaterialId": "3a1c68c8-0574-f2e4-33b3-90d813567939",
+                    "code": null,
+                    "name": "BTDA-DD",
+                    "quantity": "300000",
+                    "lockQuantity": "28",
+                    "unit": "微升",
+                    "x": 1,
+                    "y": 1,
+                    "z": 1,
+                    "associateId": null
+                },
+                {
+                    "id": "3a1c68c8-0574-e717-1b1b-99891f875455",
+                    "detailMaterialId": "3a1c68c8-0574-a0ef-e636-68cdc98960e2",
+                    "code": null,
+                    "name": "BTDA-3",
+                    "quantity": "300000",
+                    "lockQuantity": "4",
+                    "unit": "微升",
+                    "x": 2,
+                    "y": 3,
+                    "z": 1,
+                    "associateId": null
+                },
+                {
+                    "id": "3a1c68c8-0574-e9bd-6cca-5e261b4f89cb",
+                    "detailMaterialId": "3a1c68c8-0574-9d11-5115-283e8e5510b1",
+                    "code": null,
+                    "name": "BTDA-1",
+                    "quantity": "300000",
+                    "lockQuantity": "4",
+                    "unit": "微升",
+                    "x": 2,
+                    "y": 1,
+                    "z": 1,
+                    "associateId": null
+                }
+            ]
+        }
+    ],
+    "code": 1,
+    "message": "",
+    "timestamp": 1758560573511
+}

test/resources/test_bottle_carrier.py

@@ -0,0 +1,48 @@
+import pytest
+
+from unilabos.resources.bioyond.bottle_carriers import BIOYOND_Electrolyte_6VialCarrier, BIOYOND_Electrolyte_1BottleCarrier
+from unilabos.resources.bioyond.bottles import BIOYOND_PolymerStation_Solid_Vial, BIOYOND_PolymerStation_Solution_Beaker, BIOYOND_PolymerStation_Reagent_Bottle
+
+
+def test_bottle_carrier() -> "BottleCarrier":
+    print("创建载架...")
+
+    # 创建6瓶载架
+    bottle_carrier = BIOYOND_Electrolyte_6VialCarrier("powder_carrier_01")
+    print(f"6瓶载架: {bottle_carrier.name}, 位置数: {len(bottle_carrier.sites)}")
+
+    # 创建1烧杯载架
+    beaker_carrier = BIOYOND_Electrolyte_1BottleCarrier("solution_carrier_01")
+    print(f"1烧杯载架: {beaker_carrier.name}, 位置数: {len(beaker_carrier.sites)}")
+
+    # 创建瓶子和烧杯
+    powder_bottle = BIOYOND_PolymerStation_Solid_Vial("powder_bottle_01")
+    solution_beaker = BIOYOND_PolymerStation_Solution_Beaker("solution_beaker_01")
+    reagent_bottle = BIOYOND_PolymerStation_Reagent_Bottle("reagent_bottle_01")
+
+    print(f"\n创建的物料:")
+    print(f"粉末瓶: {powder_bottle.name} - {powder_bottle.diameter}mm x {powder_bottle.height}mm, {powder_bottle.max_volume}μL")
+    print(f"溶液烧杯: {solution_beaker.name} - {solution_beaker.diameter}mm x {solution_beaker.height}mm, {solution_beaker.max_volume}μL")
+    print(f"试剂瓶: {reagent_bottle.name} - {reagent_bottle.diameter}mm x {reagent_bottle.height}mm, {reagent_bottle.max_volume}μL")
+
+    # 测试放置容器
+    print(f"\n测试放置容器...")
+
+    # 通过载架的索引操作来放置容器
+    # bottle_carrier[0] = powder_bottle  # 放置粉末瓶到第一个位置
+    print(f"粉末瓶已放置到6瓶载架的位置 0")
+
+    # beaker_carrier[0] = solution_beaker  # 放置烧杯到第一个位置
+    print(f"溶液烧杯已放置到1烧杯载架的位置 0")
+
+    # 验证放置结果
+    print(f"\n验证放置结果:")
+    bottle_at_0 = bottle_carrier[0].resource
+    beaker_at_0 = beaker_carrier[0].resource
+
+    if bottle_at_0:
+        print(f"位置 0 的瓶子: {bottle_at_0.name}")
+    if beaker_at_0:
+        print(f"位置 0 的烧杯: {beaker_at_0.name}")
+
+    print("\n载架设置完成！")

test/resources/test_converter_bioyond.py

@@ -0,0 +1,35 @@
+import pytest
+import json
+import os
+
+from unilabos.resources.graphio import resource_bioyond_to_plr
+from unilabos.registry.registry import lab_registry
+
+from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
+
+lab_registry.setup()
+
+
+type_mapping = {
+    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
+    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
+    "样品板": "BIOYOND_PolymerStation_6VialCarrier",
+}
+
+@pytest.fixture
+def bioyond_materials() -> list[dict]:
+    print("加载 BioYond 物料数据...")
+    print(os.getcwd())
+    with open("bioyond_materials.json", "r", encoding="utf-8") as f:
+        data = json.load(f)["data"]
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+def test_bioyond_to_plr(bioyond_materials) -> list[dict]:
+    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
+    print("将 BioYond 物料数据转换为 PLR 格式...")
+    output = resource_bioyond_to_plr(bioyond_materials, type_mapping=type_mapping, deck=deck)
+    print(deck.summary())
+    print([resource.serialize() for resource in output])
+    print([resource.serialize_all_state() for resource in output])

unilabos-linux-64.yaml

@@ -1,5 +1,6 @@
 name: unilab
 channels:
+  - unilab
   - robostack
   - robostack-staging
   - conda-forge
@@ -33,7 +34,7 @@ dependencies:
   - uvicorn
   - gradio
   - flask
-  - websocket
+  - websockets
   # Notebook
   - ipython
   - jupyter
@@ -48,8 +49,9 @@ dependencies:
   - ros-humble-ros2-control
   - ros-humble-robot-state-publisher
   - ros-humble-joint-state-publisher
-  # web
+  # web and visualization
   - ros-humble-rosbridge-server
+  - ros-humble-cv-bridge
   # geometry & motion planning
   - ros-humble-tf2
   - ros-humble-moveit
@@ -60,6 +62,11 @@ dependencies:
   - transforms3d
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
-#  - ros-humble-unilabos-msgs
+  - uni-lab::ros-humble-unilabos-msgs
+  - zeep
+  - jinja2
+  - pprp
   - pip:
       - paho-mqtt
+      - opentrons_shared_data
+      - git+https://github.com/Xuwznln/pylabrobot

unilabos-osx-64.yaml

@@ -1,5 +1,6 @@
 name: unilab
 channels:
+  - unilab
   - robostack
   - robostack-staging
   - conda-forge
@@ -33,7 +34,7 @@ dependencies:
   - uvicorn
   - gradio
   - flask
-  - websocket
+  - websockets
   # Notebook
   - ipython
   - jupyter
@@ -60,6 +61,11 @@ dependencies:
   - transforms3d
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
-#  - ros-humble-unilabos-msgs
+  - uni-lab::ros-humble-unilabos-msgs
+  - zeep
+  - jinja2
+  - pprp
   - pip:
       - paho-mqtt
+      - opentrons_shared_data
+      - git+https://github.com/Xuwznln/pylabrobot

unilabos-osx-arm64.yaml

@@ -1,5 +1,6 @@
 name: unilab
 channels:
+  - unilab
   - robostack
   - robostack-staging
   - conda-forge
@@ -34,8 +35,7 @@ dependencies:
   - uvicorn
   - gradio
   - flask
-  - websocket
-  - paho-mqtt
+  - websockets
   # Notebook
   - ipython
   - jupyter
@@ -50,8 +50,9 @@ dependencies:
   - ros-humble-ros2-control
   - ros-humble-robot-state-publisher
   - ros-humble-joint-state-publisher
-  # web
+  # web and visualization
   - ros-humble-rosbridge-server
+  - ros-humble-cv-bridge
   # geometry & motion planning
   - ros-humble-tf2
   - ros-humble-moveit
@@ -62,6 +63,11 @@ dependencies:
   - transforms3d
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
-#  - ros-humble-unilabos-msgs
+  - uni-lab::ros-humble-unilabos-msgs
+  - zeep
+  - jinja2
+  - pprp
   - pip:
       - paho-mqtt
+      - opentrons_shared_data
+      - git+https://github.com/Xuwznln/pylabrobot

unilabos-win64.yaml

@@ -1,17 +1,18 @@
 name: unilab
 channels:
+  - unilab
   - robostack
   - robostack-staging
   - conda-forge
 dependencies:
   # Basics
   - python=3.11.11
-  - compilers
-  - cmake
-  - make
-  - ninja
-  - sphinx
-  - sphinx_rtd_theme
+  # - compilers
+  # - cmake
+  # - make
+  # - ninja
+  # - sphinx
+  # - sphinx_rtd_theme
   # Data Visualization
   - numpy
   - scipy
@@ -23,7 +24,7 @@ dependencies:
   - pyserial
   - pyusb
   - pylibftdi
-  - pymodbus
+  - pymodbus==3.6.9
   - python-can
   - pyvisa
   - opencv
@@ -33,7 +34,7 @@ dependencies:
   - uvicorn
   - gradio
   - flask
-  - websocket
+  - websockets
   # Notebook
   - ipython
   - jupyter
@@ -48,8 +49,9 @@ dependencies:
   - ros-humble-ros2-control
   - ros-humble-robot-state-publisher
   - ros-humble-joint-state-publisher
-  # web
+  # web and visualization
   - ros-humble-rosbridge-server
+  - ros-humble-cv-bridge
   # geometry & motion planning
   - ros-humble-tf2
   - ros-humble-moveit
@@ -60,6 +62,18 @@ dependencies:
   - transforms3d
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
-  # ros-humble-unilabos-msgs
+  - uni-lab::ros-humble-unilabos-msgs
+  # driver
+  #- crcmod
+  - zeep
+  - jinja2
+  - pprp
   - pip:
       - paho-mqtt
+      - opentrons_shared_data
+      - git+https://github.com/Xuwznln/pylabrobot
+      # driver
+      #- ur-rtde  # set PYTHONUTF8=1
+      #- pyautogui
+      #- pywinauto
+      #- pywinauto_recorder

unilabos/app/backend.py

@@ -8,22 +8,23 @@ def start_backend(
     backend: str,
     devices_config: dict = {},
     resources_config: list = [],
+    resources_edge_config: list = [],
     graph=None,
     controllers_config: dict = {},
     bridges=[],
     without_host: bool = False,
     visual: str = "None",
     resources_mesh_config: dict = {},
-    **kwargs
+    **kwargs,
 ):
     if backend == "ros":
         # 假设 ros_main, simple_main, automancer_main 是不同 backend 的启动函数
         from unilabos.ros.main_slave_run import main, slave  # 如果选择 'ros' 作为 backend
-    elif backend == 'simple':
+    elif backend == "simple":
         # 这里假设 simple_backend 和 automancer_backend 是你定义的其他两个后端
         # from simple_backend import main as simple_main
         pass
-    elif backend == 'automancer':
+    elif backend == "automancer":
         # from automancer_backend import main as automancer_main
         pass
     else:
@@ -31,7 +32,16 @@ def start_backend(
 
     backend_thread = threading.Thread(
         target=main if not without_host else slave,
-        args=(devices_config, resources_config, graph, controllers_config, bridges, visual, resources_mesh_config),
+        args=(
+            devices_config,
+            resources_config,
+            resources_edge_config,
+            graph,
+            controllers_config,
+            bridges,
+            visual,
+            resources_mesh_config,
+        ),
         name="backend_thread",
         daemon=True,
     )

unilabos/app/communication.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+通信模块
+
+提供WebSocket的统一接口，支持通过配置选择通信协议。
+包含通信抽象层基类和通信客户端工厂。
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+from unilabos.config.config import BasicConfig
+from unilabos.utils import logger
+
+
+class BaseCommunicationClient(ABC):
+    """
+    通信客户端抽象基类
+
+    定义了所有通信客户端（WebSocket等）需要实现的接口。
+    """
+
+    def __init__(self):
+        self.is_disabled = True
+        self.client_id = ""
+
+    @abstractmethod
+    def start(self) -> None:
+        """
+        启动通信客户端连接
+        """
+        pass
+
+    @abstractmethod
+    def stop(self) -> None:
+        """
+        停止通信客户端连接
+        """
+        pass
+
+    @abstractmethod
+    def publish_device_status(self, device_status: dict, device_id: str, property_name: str) -> None:
+        """
+        发布设备状态信息
+
+        Args:
+            device_status: 设备状态字典
+            device_id: 设备ID
+            property_name: 属性名称
+        """
+        pass
+
+    @abstractmethod
+    def publish_job_status(
+        self, feedback_data: dict, job_id: str, status: str, return_info: Optional[dict] = None
+    ) -> None:
+        """
+        发布作业状态信息
+
+        Args:
+            feedback_data: 反馈数据
+            job_id: 作业ID
+            status: 作业状态
+            return_info: 返回信息
+        """
+        pass
+
+    @abstractmethod
+    def send_ping(self, ping_id: str, timestamp: float) -> None:
+        """
+        发送ping消息
+
+        Args:
+            ping_id: ping ID
+            timestamp: 时间戳
+        """
+        pass
+
+    def setup_pong_subscription(self) -> None:
+        """
+        设置pong消息订阅（可选实现）
+        """
+        pass
+
+    @property
+    def is_connected(self) -> bool:
+        """
+        检查是否已连接
+
+        Returns:
+            是否已连接
+        """
+        return not self.is_disabled
+
+
+class CommunicationClientFactory:
+    """
+    通信客户端工厂类
+
+    根据配置文件中的通信协议设置创建相应的客户端实例。
+    """
+
+    _client_cache: Optional[BaseCommunicationClient] = None
+
+    @classmethod
+    def create_client(cls, protocol: Optional[str] = None) -> BaseCommunicationClient:
+        """
+        创建通信客户端实例
+
+        Args:
+            protocol: 指定的协议类型，如果为None则使用配置文件中的设置
+
+        Returns:
+            通信客户端实例
+
+        Raises:
+            ValueError: 当协议类型不支持时
+        """
+        if protocol is None:
+            protocol = BasicConfig.communication_protocol
+
+        protocol = protocol.lower()
+
+        if protocol == "websocket":
+            return cls._create_websocket_client()
+        else:
+            logger.error(f"[CommunicationFactory] Unsupported protocol: {protocol}")
+            logger.warning(f"[CommunicationFactory] Falling back to WebSocket")
+            return cls._create_websocket_client()
+
+    @classmethod
+    def get_client(cls, protocol: Optional[str] = None) -> BaseCommunicationClient:
+        """
+        获取通信客户端实例（单例模式）
+
+        Args:
+            protocol: 指定的协议类型，如果为None则使用配置文件中的设置
+
+        Returns:
+            通信客户端实例
+        """
+        if cls._client_cache is None:
+            cls._client_cache = cls.create_client(protocol)
+            logger.info(f"[CommunicationFactory] Created {type(cls._client_cache).__name__} client")
+
+        return cls._client_cache
+
+    @classmethod
+    def _create_websocket_client(cls) -> BaseCommunicationClient:
+        """创建WebSocket客户端"""
+        try:
+            from unilabos.app.ws_client import WebSocketClient
+
+            return WebSocketClient()
+        except Exception as e:
+            logger.error(f"[CommunicationFactory] Failed to create WebSocket client: {str(e)}")
+            raise
+
+    @classmethod
+    def reset_client(cls):
+        """重置客户端缓存（用于测试或重新配置）"""
+        if cls._client_cache:
+            try:
+                cls._client_cache.stop()
+            except Exception as e:
+                logger.warning(f"[CommunicationFactory] Error stopping old client: {str(e)}")
+
+        cls._client_cache = None
+        logger.info("[CommunicationFactory] Client cache reset")
+
+    @classmethod
+    def get_supported_protocols(cls) -> list[str]:
+        """
+        获取支持的协议列表
+
+        Returns:
+            支持的协议列表
+        """
+        return ["websocket"]
+
+
+def get_communication_client(protocol: Optional[str] = None) -> BaseCommunicationClient:
+    """
+    获取通信客户端实例的便捷函数
+
+    Args:
+        protocol: 指定的协议类型，如果为None则使用配置文件中的设置
+
+    Returns:
+        通信客户端实例
+    """
+    return CommunicationClientFactory.get_client(protocol)

unilabos/app/controler.py

@@ -1,36 +0,0 @@
-
-import json
-import uuid
-from unilabos.app.model import JobAddReq, JobData
-from unilabos.ros.nodes.presets.host_node import HostNode
-
-
-def get_resources() -> tuple:
-    if HostNode.get_instance() is None:
-        return False, "Host node not initialized"
-
-    return True, HostNode.get_instance().resources_config
-
-def devices() -> tuple:
-    if HostNode.get_instance() is None:
-        return False, "Host node not initialized"
-    
-    return True, HostNode.get_instance().devices_config
-
-def job_info(id: str):
-    get_goal_status = HostNode.get_instance().get_goal_status(id)
-    return JobData(jobId=id, status=get_goal_status)
-
-def job_add(req: JobAddReq) -> JobData:
-    if req.job_id is None:
-        req.job_id = str(uuid.uuid4())
-    action_name = req.data["action"]
-    action_kwargs = req.data["action_kwargs"]
-    req.data['action'] = action_name
-    if action_name == "execute_command_from_outer":
-        action_kwargs = {"command": json.dumps(action_kwargs)}
-    elif "command" in action_kwargs:
-        action_kwargs = action_kwargs["command"]
-    # print(f"job_add:{req.device_id} {action_name} {action_kwargs}")
-    HostNode.get_instance().send_goal(req.device_id, action_name=action_name, action_kwargs=action_kwargs, goal_uuid=req.job_id, server_info=req.server_info)
-    return JobData(jobId=req.job_id)

unilabos/app/main.py

@@ -1,7 +1,7 @@
 import argparse
 import asyncio
-import json
 import os
+import shutil
 import signal
 import sys
 import threading
@@ -10,7 +10,6 @@ from copy import deepcopy
 
 import yaml
 
-from unilabos.resources.graphio import tree_to_list
 
 # 首先添加项目根目录到路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -18,87 +17,14 @@ unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
     sys.path.append(unilabos_dir)
 
-from unilabos.config.config import load_config, BasicConfig, _update_config_from_env
+from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 from unilabos.utils.banner_print import print_status, print_unilab_banner
+from unilabos.resources.graphio import modify_to_backend_format
 
 
-def parse_args():
-    """解析命令行参数"""
-    parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
-    parser.add_argument("-g", "--graph", help="Physical setup graph.")
-    parser.add_argument("-d", "--devices", help="Devices config file.")
-    parser.add_argument("-r", "--resources", help="Resources config file.")
-    parser.add_argument("-c", "--controllers", default=None, help="Controllers config file.")
-    parser.add_argument(
-        "--registry_path",
-        type=str,
-        default=None,
-        action="append",
-        help="Path to the registry",
-    )
-    parser.add_argument(
-        "--backend",
-        choices=["ros", "simple", "automancer"],
-        default="ros",
-        help="Choose the backend to run with: 'ros', 'simple', or 'automancer'.",
-    )
-    parser.add_argument(
-        "--app_bridges",
-        nargs="+",
-        default=["mqtt", "fastapi"],
-        help="Bridges to connect to. Now support 'mqtt' and 'fastapi'.",
-    )
-    parser.add_argument(
-        "--without_host",
-        action="store_true",
-        help="Run the backend as slave (without host).",
-    )
-    parser.add_argument(
-        "--slave_no_host",
-        action="store_true",
-        help="Slave模式下跳过等待host服务",
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default=None,
-        help="配置文件路径，支持.py格式的Python配置文件",
-    )
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=8002,
-        help="信息页web服务的启动端口",
-    )
-    parser.add_argument(
-        "--disable_browser",
-        action='store_true',
-        help="是否在启动时关闭信息页",
-    )
-    parser.add_argument(
-        "--2d_vis",
-        action='store_true',
-        help="是否在pylabrobot实例启动时，同时启动可视化",
-    )
-    parser.add_argument(
-        "--visual",
-        choices=["rviz", "web", "disable"],
-        default="disable",
-        help="选择可视化工具: rviz, web",
-    )
-    return parser.parse_args()
-
-
-def main():
-    """主函数"""
-    # 解析命令行参数
-    args = parse_args()
-    args_dict = vars(args)
-
-    # 加载配置文件，优先加载config，然后从env读取
-    config_path = args_dict.get("config")
+def load_config_from_file(config_path):
     if config_path is None:
-        config_path = os.environ.get("UNILABOS.BASICCONFIG.CONFIG_PATH", None)
+        config_path = os.environ.get("UNILABOS_BASICCONFIG_CONFIG_PATH", None)
     if config_path:
         if not os.path.exists(config_path):
             print_status(f"配置文件 {config_path} 不存在", "error")
@@ -110,9 +36,218 @@ def main():
         print_status(f"启动 UniLab-OS时，配置文件参数未正确传入 --config '{config_path}' 尝试本地配置...", "warning")
         load_config(config_path)
 
+
+def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
+    # easier for user input, easier for dev search code
+    option_strings = list(args._option_string_actions.keys())
+    for i, arg in enumerate(sys.argv):
+        for option_string in option_strings:
+            if arg.startswith(option_string):
+                new_arg = arg[:2] + arg[2 : len(option_string)].replace("-", "_") + arg[len(option_string) :]
+                sys.argv[i] = new_arg
+                break
+
+
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
+    parser.add_argument("-g", "--graph", help="Physical setup graph file path.")
+    parser.add_argument("-c", "--controllers", default=None, help="Controllers config file path.")
+    parser.add_argument(
+        "--registry_path",
+        type=str,
+        default=None,
+        action="append",
+        help="Path to the registry directory",
+    )
+    parser.add_argument(
+        "--working_dir",
+        type=str,
+        default=None,
+        help="Path to the working directory",
+    )
+    parser.add_argument(
+        "--backend",
+        choices=["ros", "simple", "automancer"],
+        default="ros",
+        help="Choose the backend to run with: 'ros', 'simple', or 'automancer'.",
+    )
+    parser.add_argument(
+        "--app_bridges",
+        nargs="+",
+        default=["websocket", "fastapi"],
+        help="Bridges to connect to. Now support 'websocket' and 'fastapi'.",
+    )
+    parser.add_argument(
+        "--is_slave",
+        action="store_true",
+        help="Run the backend as slave node (without host privileges).",
+    )
+    parser.add_argument(
+        "--slave_no_host",
+        action="store_true",
+        help="Skip waiting for host service in slave mode",
+    )
+    parser.add_argument(
+        "--upload_registry",
+        action="store_true",
+        help="Upload registry information when starting unilab",
+    )
+    parser.add_argument(
+        "--use_remote_resource",
+        action="store_true",
+        help="Use remote resources when starting unilab",
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default=None,
+        help="Configuration file path, supports .py format Python config files",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8002,
+        help="Port for web service information page",
+    )
+    parser.add_argument(
+        "--disable_browser",
+        action="store_true",
+        help="Disable opening information page on startup",
+    )
+    parser.add_argument(
+        "--2d_vis",
+        action="store_true",
+        help="Enable 2D visualization when starting pylabrobot instance",
+    )
+    parser.add_argument(
+        "--visual",
+        choices=["rviz", "web", "disable"],
+        default="disable",
+        help="Choose visualization tool: rviz, web, or disable",
+    )
+    parser.add_argument(
+        "--ak",
+        type=str,
+        default="",
+        help="Access key for laboratory requests",
+    )
+    parser.add_argument(
+        "--sk",
+        type=str,
+        default="",
+        help="Secret key for laboratory requests",
+    )
+    parser.add_argument(
+        "--addr",
+        type=str,
+        default="https://uni-lab.bohrium.com/api/v1",
+        help="Laboratory backend address",
+    )
+    parser.add_argument(
+        "--skip_env_check",
+        action="store_true",
+        help="Skip environment dependency check on startup",
+    )
+    parser.add_argument(
+        "--complete_registry",
+        action="store_true",
+        default=False,
+        help="Complete registry information",
+    )
+    return parser
+
+
+def main():
+    """主函数"""
+    # 解析命令行参数
+    args = parse_args()
+    convert_argv_dashes_to_underscores(args)
+    args_dict = vars(args.parse_args())
+
+    # 环境检查 - 检查并自动安装必需的包 (可选)
+    if not args_dict.get("skip_env_check", False):
+        from unilabos.utils.environment_check import check_environment
+
+        print_status("正在进行环境依赖检查...", "info")
+        if not check_environment(auto_install=True):
+            print_status("环境检查失败，程序退出", "error")
+            os._exit(1)
+    else:
+        print_status("跳过环境依赖检查", "warning")
+
+    # 加载配置文件，优先加载config，然后从env读取
+    config_path = args_dict.get("config")
+    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"))
+    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",
+                )
+                os._exit(1)
+    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")
+    load_config_from_file(config_path)
+    if args_dict["addr"] == "test":
+        print_status("使用测试环境地址", "info")
+        HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
+    elif args_dict["addr"] == "uat":
+        print_status("使用uat环境地址", "info")
+        HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
+    elif args_dict["addr"] == "local":
+        print_status("使用本地环境地址", "info")
+        HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
+    else:
+        HTTPConfig.remote_addr = args_dict.get("addr", "")
+
+    if args_dict["use_remote_resource"]:
+        print_status("使用远程资源启动", "info")
+        from unilabos.app.web import http_client
+
+        res = http_client.resource_get("host_node", False)
+        if str(res.get("code", 0)) == "0" and len(res.get("data", [])) > 0:
+            print_status("远程资源已存在，使用云端物料！", "info")
+            args_dict["graph"] = None
+        else:
+            print_status("远程资源不存在，本地将进行首次上报！", "info")
+
     # 设置BasicConfig参数
-    BasicConfig.is_host_mode = not args_dict.get("without_host", False)
+    if args_dict.get("ak", ""):
+        BasicConfig.ak = args_dict.get("ak", "")
+        print_status("传入了ak参数，优先采用传入参数！", "info")
+    if args_dict.get("sk", ""):
+        BasicConfig.sk = args_dict.get("sk", "")
+        print_status("传入了sk参数，优先采用传入参数！", "info")
+    BasicConfig.working_dir = working_dir
+    BasicConfig.is_host_mode = not args_dict.get("is_slave", False)
     BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
+    BasicConfig.upload_registry = args_dict.get("upload_registry", False)
+    BasicConfig.communication_protocol = "websocket"
     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
@@ -125,45 +260,101 @@ def main():
         dict_to_nested_dict,
         initialize_resources,
     )
-    from unilabos.app.mq import mqtt_client
+    from unilabos.app.communication import get_communication_client
     from unilabos.registry.registry import build_registry
     from unilabos.app.backend import start_backend
     from unilabos.app.web import http_client
     from unilabos.app.web import start_server
+    from unilabos.app.register import register_devices_and_resources
 
     # 显示启动横幅
     print_unilab_banner(args_dict)
 
     # 注册表
-    build_registry(args_dict["registry_path"])
+    lab_registry = build_registry(
+        args_dict["registry_path"], args_dict.get("complete_registry", False), args_dict["upload_registry"]
+    )
 
-    devices_and_resources = None
-    if args_dict["graph"] is not None:
-        import unilabos.resources.graphio as graph_res
-        graph_res.physical_setup_graph = (
-            read_node_link_json(args_dict["graph"])
-            if args_dict["graph"].endswith(".json")
-            else read_graphml(args_dict["graph"])
-        )
-        devices_and_resources = dict_from_graph(graph_res.physical_setup_graph)
-        # args_dict["resources_config"] = initialize_resources(list(deepcopy(devices_and_resources).values()))
-        args_dict["resources_config"] = list(devices_and_resources.values())
-        args_dict["devices_config"] = dict_to_nested_dict(deepcopy(devices_and_resources), devices_only=False)
-        args_dict["graph"] = graph_res.physical_setup_graph
+    if not BasicConfig.ak or not BasicConfig.sk:
+        print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
+        os._exit(1)
+    if args_dict["graph"] is None:
+        request_startup_json = http_client.request_startup_json()
+        if not request_startup_json:
+            print_status(
+                "未指定设备加载文件路径，尝试从HTTP获取失败，请检查网络或者使用-g参数指定设备加载文件路径", "error"
+            )
+            os._exit(1)
+        else:
+            print_status("联网获取设备加载文件成功", "info")
+        graph, data = read_node_link_json(request_startup_json)
     else:
-        if args_dict["devices"] is None or args_dict["resources"] is None:
-            print_status("Either graph or devices and resources must be provided.", "error")
-            sys.exit(1)
-        args_dict["devices_config"] = json.load(open(args_dict["devices"], encoding="utf-8"))
-        # args_dict["resources_config"] = initialize_resources(
-        #     list(json.load(open(args_dict["resources"], encoding="utf-8")).values())
-        # )
-        args_dict["resources_config"] = list(json.load(open(args_dict["resources"], encoding="utf-8")).values())
+        file_path = args_dict["graph"]
+        if file_path.endswith(".json"):
+            graph, data = read_node_link_json(file_path)
+        else:
+            graph, data = read_graphml(file_path)
+    import unilabos.resources.graphio as graph_res
+
+    graph_res.physical_setup_graph = graph
+    resource_edge_info = modify_to_backend_format(data["links"])
+    materials = lab_registry.obtain_registry_resource_info()
+    materials.extend(lab_registry.obtain_registry_device_info())
+    materials = {k["id"]: k for k in materials}
+    nodes = {k["id"]: k for k in data["nodes"]}
+    edge_info = len(resource_edge_info)
+    for ind, i in enumerate(resource_edge_info[::-1]):
+        source_node = nodes[i["source"]]
+        target_node = nodes[i["target"]]
+        source_handle = i["sourceHandle"]
+        target_handle = i["targetHandle"]
+        source_handler_keys = [
+            h["handler_key"] for h in materials[source_node["class"]]["handles"] if h["io_type"] == "source"
+        ]
+        target_handler_keys = [
+            h["handler_key"] for h in materials[target_node["class"]]["handles"] if h["io_type"] == "target"
+        ]
+        if source_handle not in source_handler_keys:
+            print_status(
+                f"节点 {source_node['id']} 的source端点 {source_handle} 不存在，请检查，支持的端点 {source_handler_keys}",
+                "error",
+            )
+            resource_edge_info.pop(edge_info - ind - 1)
+            continue
+        if target_handle not in target_handler_keys:
+            print_status(
+                f"节点 {target_node['id']} 的target端点 {target_handle} 不存在，请检查，支持的端点 {target_handler_keys}",
+                "error",
+            )
+            resource_edge_info.pop(edge_info - ind - 1)
+            continue
+
+    devices_and_resources = dict_from_graph(graph_res.physical_setup_graph)
+    # args_dict["resources_config"] = initialize_resources(list(deepcopy(devices_and_resources).values()))
+    args_dict["resources_config"] = list(devices_and_resources.values())
+    args_dict["devices_config"] = dict_to_nested_dict(deepcopy(devices_and_resources), devices_only=False)
+    args_dict["graph"] = graph_res.physical_setup_graph
 
     print_status(f"{len(args_dict['resources_config'])} Resources loaded:", "info")
     for i in args_dict["resources_config"]:
         print_status(f"DeviceId: {i['id']}, Class: {i['class']}", "info")
 
+    if BasicConfig.upload_registry:
+        # 设备注册到服务端 - 需要 ak 和 sk
+        if args_dict.get("ak") and args_dict.get("sk"):
+            print_status("开始注册设备到服务端...", "info")
+            try:
+                register_devices_and_resources(lab_registry)
+                print_status("设备注册完成", "info")
+            except Exception as e:
+                print_status(f"设备注册失败: {e}", "error")
+        else:
+            print_status("未提供 ak 和 sk，跳过设备注册", "info")
+    else:
+        print_status(
+            "本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning"
+        )
+
     if args_dict["controllers"] is not None:
         args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
     else:
@@ -171,31 +362,44 @@ def main():
 
     args_dict["bridges"] = []
 
-    if "mqtt" in args_dict["app_bridges"]:
-        args_dict["bridges"].append(mqtt_client)
+    # 获取通信客户端（仅支持WebSocket）
+    comm_client = get_communication_client()
+
+    if "websocket" in args_dict["app_bridges"]:
+        args_dict["bridges"].append(comm_client)
     if "fastapi" in args_dict["app_bridges"]:
         args_dict["bridges"].append(http_client)
-    if "mqtt" in args_dict["app_bridges"]:
+    if "websocket" in args_dict["app_bridges"]:
 
         def _exit(signum, frame):
-            mqtt_client.stop()
+            comm_client.stop()
             sys.exit(0)
 
         signal.signal(signal.SIGINT, _exit)
         signal.signal(signal.SIGTERM, _exit)
-        mqtt_client.start()
+        comm_client.start()
     args_dict["resources_mesh_config"] = {}
+    args_dict["resources_edge_config"] = resource_edge_info
     # web visiualize 2D
     if args_dict["visual"] != "disable":
         enable_rviz = args_dict["visual"] == "rviz"
         if devices_and_resources is not None:
-            from unilabos.device_mesh.resource_visalization import ResourceVisualization  # 此处开启后，logger会变更为INFO，有需要请调整
-            resource_visualization = ResourceVisualization(devices_and_resources, args_dict["resources_config"] ,enable_rviz=enable_rviz)
+            from unilabos.device_mesh.resource_visalization import (
+                ResourceVisualization,
+            )  # 此处开启后，logger会变更为INFO，有需要请调整
+
+            resource_visualization = ResourceVisualization(
+                devices_and_resources, args_dict["resources_config"], enable_rviz=enable_rviz
+            )
             args_dict["resources_mesh_config"] = resource_visualization.resource_model
             start_backend(**args_dict)
-            server_thread = threading.Thread(target=start_server, kwargs=dict(
-                open_browser=not args_dict["disable_browser"], port=args_dict["port"],
-            ))
+            server_thread = threading.Thread(
+                target=start_server,
+                kwargs=dict(
+                    open_browser=not args_dict["disable_browser"],
+                    port=args_dict["port"],
+                ),
+            )
             server_thread.start()
             asyncio.set_event_loop(asyncio.new_event_loop())
             resource_visualization.start()
@@ -203,10 +407,16 @@ def main():
                 time.sleep(1)
         else:
             start_backend(**args_dict)
-            start_server(open_browser=not args_dict["disable_browser"], port=args_dict["port"],)
+            start_server(
+                open_browser=not args_dict["disable_browser"],
+                port=args_dict["port"],
+            )
     else:
         start_backend(**args_dict)
-        start_server(open_browser=not args_dict["disable_browser"], port=args_dict["port"],)
+        start_server(
+            open_browser=not args_dict["disable_browser"],
+            port=args_dict["port"],
+        )
 
 
 if __name__ == "__main__":

unilabos/app/model.py

@@ -50,11 +50,16 @@ class Resp(BaseModel):
 
 class JobAddReq(BaseModel):
     device_id: str = Field(examples=["Gripper"], description="device id")
-    data: dict = Field(examples=[{"position": 30, "torque": 5, "action": "push_to"}])
+    action: str = Field(examples=["_execute_driver_command_async"], description="action name", default="")
+    action_type: str = Field(examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action name", default="")
+    action_args: dict = Field(examples=[{'string': 'string'}], description="action name", default="")
+    task_id: str = Field(examples=["task_id"], description="task uuid")
     job_id: str = Field(examples=["job_id"], description="goal uuid")
     node_id: str = Field(examples=["node_id"], description="node uuid")
     server_info: dict = Field(examples=[{"send_timestamp": 1717000000.0}], description="server info")
 
+    data: dict = Field(examples=[{"position": 30, "torque": 5, "action": "push_to"}], default={})
+
 
 class JobStepFinishReq(BaseModel):
     token: str = Field(examples=["030944"], description="token")

unilabos/app/mq.py

@@ -1,216 +0,0 @@
-import json
-import time
-import traceback
-from typing import Optional
-import uuid
-
-import paho.mqtt.client as mqtt
-import ssl
-import base64
-import hmac
-from hashlib import sha1
-import tempfile
-import os
-
-from unilabos.config.config import MQConfig
-from unilabos.app.controler import job_add
-from unilabos.app.model import JobAddReq
-from unilabos.utils import logger
-from unilabos.utils.type_check import TypeEncoder
-
-from paho.mqtt.enums import CallbackAPIVersion
-
-
-class MQTTClient:
-    mqtt_disable = True
-
-    def __init__(self):
-        self.mqtt_disable = not MQConfig.lab_id
-        self.client_id = f"{MQConfig.group_id}@@@{MQConfig.lab_id}{uuid.uuid4()}"
-        logger.info("[MQTT] Client_id: " + self.client_id)
-        self.client = mqtt.Client(CallbackAPIVersion.VERSION2, client_id=self.client_id, protocol=mqtt.MQTTv5)
-        self._setup_callbacks()
-
-    def _setup_callbacks(self):
-        self.client.on_log = self._on_log
-        self.client.on_connect = self._on_connect
-        self.client.on_message = self._on_message
-        self.client.on_disconnect = self._on_disconnect
-
-    def _on_log(self, client, userdata, level, buf):
-        # logger.info(f"[MQTT] log: {buf}")
-        pass
-
-    def _on_connect(self, client, userdata, flags, rc, properties=None):
-        logger.info("[MQTT] Connected with result code " + str(rc))
-        client.subscribe(f"labs/{MQConfig.lab_id}/job/start/", 0)
-        client.subscribe(f"labs/{MQConfig.lab_id}/pong/", 0)
-
-    def _on_message(self, client, userdata, msg) -> None:
-        # logger.info("[MQTT] on_message<<<< " + msg.topic + " " + str(msg.payload))
-        try:
-            payload_str = msg.payload.decode("utf-8")
-            payload_json = json.loads(payload_str)
-            if msg.topic == f"labs/{MQConfig.lab_id}/job/start/":
-                if "data" not in payload_json:
-                    payload_json["data"] = {}
-                if "action" in payload_json:
-                    payload_json["data"]["action"] = payload_json.pop("action")
-                if "action_kwargs" in payload_json:
-                    payload_json["data"]["action_kwargs"] = payload_json.pop("action_kwargs")
-                job_req = JobAddReq.model_validate(payload_json)
-                data = job_add(job_req)
-                return
-            elif msg.topic == f"labs/{MQConfig.lab_id}/pong/":
-                # 处理pong响应，通知HostNode
-                from unilabos.ros.nodes.presets.host_node import HostNode
-
-                host_instance = HostNode.get_instance(0)
-                if host_instance:
-                    host_instance.handle_pong_response(payload_json)
-                return
-
-        except json.JSONDecodeError as e:
-            logger.error(f"[MQTT] JSON 解析错误: {e}")
-            logger.error(f"[MQTT] Raw message: {msg.payload}")
-            logger.error(traceback.format_exc())
-        except Exception as e:
-            logger.error(f"[MQTT] 处理消息时出错: {e}")
-            logger.error(traceback.format_exc())
-
-    def _on_disconnect(self, client, userdata, rc, reasonCode=None, properties=None):
-        if rc != 0:
-            logger.error(f"[MQTT] Unexpected disconnection {rc}")
-
-    def _setup_ssl_context(self):
-        temp_files = []
-        try:
-            with tempfile.NamedTemporaryFile(mode="w", delete=False) as ca_temp:
-                ca_temp.write(MQConfig.ca_content)
-                temp_files.append(ca_temp.name)
-
-            with tempfile.NamedTemporaryFile(mode="w", delete=False) as cert_temp:
-                cert_temp.write(MQConfig.cert_content)
-                temp_files.append(cert_temp.name)
-
-            with tempfile.NamedTemporaryFile(mode="w", delete=False) as key_temp:
-                key_temp.write(MQConfig.key_content)
-                temp_files.append(key_temp.name)
-
-            context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
-            context.load_verify_locations(cafile=temp_files[0])
-            context.load_cert_chain(certfile=temp_files[1], keyfile=temp_files[2])
-            self.client.tls_set_context(context)
-        finally:
-            for temp_file in temp_files:
-                try:
-                    os.unlink(temp_file)
-                except Exception as e:
-                    pass
-
-    def start(self):
-        if self.mqtt_disable:
-            logger.warning("MQTT is disabled, skipping connection.")
-            return
-        userName = f"Signature|{MQConfig.access_key}|{MQConfig.instance_id}"
-        password = base64.b64encode(
-            hmac.new(MQConfig.secret_key.encode(), self.client_id.encode(), sha1).digest()
-        ).decode()
-
-        self.client.username_pw_set(userName, password)
-        self._setup_ssl_context()
-
-        # 创建连接线程
-        def connect_thread_func():
-            try:
-                self.client.connect(MQConfig.broker_url, MQConfig.port, 60)
-                self.client.loop_start()
-
-                # 添加连接超时检测
-                max_attempts = 5
-                attempt = 0
-                while not self.client.is_connected() and attempt < max_attempts:
-                    logger.info(
-                        f"[MQTT] 正在连接到 {MQConfig.broker_url}:{MQConfig.port}，尝试 {attempt+1}/{max_attempts}"
-                    )
-                    time.sleep(3)
-                    attempt += 1
-
-                if self.client.is_connected():
-                    logger.info(f"[MQTT] 已成功连接到 {MQConfig.broker_url}:{MQConfig.port}")
-                else:
-                    logger.error(f"[MQTT] 连接超时，可能是账号密码错误或网络问题")
-                    self.client.loop_stop()
-            except Exception as e:
-                logger.error(f"[MQTT] 连接失败: {str(e)}")
-
-        connect_thread_func()
-        # connect_thread = threading.Thread(target=connect_thread_func)
-        # connect_thread.daemon = True
-        # connect_thread.start()
-
-    def stop(self):
-        if self.mqtt_disable:
-            return
-        self.client.disconnect()
-        self.client.loop_stop()
-
-    def publish_device_status(self, device_status: dict, device_id, property_name):
-        # status = device_status.get(device_id, {})
-        if self.mqtt_disable:
-            return
-        status = {"data": device_status.get(device_id, {}), "device_id": device_id}
-        address = f"labs/{MQConfig.lab_id}/devices/"
-        self.client.publish(address, json.dumps(status), qos=2)
-        logger.debug(f"Device status published: address: {address}, {status}")
-
-    def publish_job_status(self, feedback_data: dict, job_id: str, status: str, return_info: Optional[str] = None):
-        if self.mqtt_disable:
-            return
-        if return_info is None:
-            return_info = "{}"
-        jobdata = {"job_id": job_id, "data": feedback_data, "status": status, "return_info": return_info}
-        self.client.publish(f"labs/{MQConfig.lab_id}/job/list/", json.dumps(jobdata), qos=2)
-
-    def publish_registry(self, device_id: str, device_info: dict):
-        if self.mqtt_disable:
-            return
-        address = f"labs/{MQConfig.lab_id}/registry/"
-        registry_data = json.dumps({device_id: device_info}, ensure_ascii=False, cls=TypeEncoder)
-        self.client.publish(address, registry_data, qos=2)
-        logger.debug(f"Registry data published: address: {address}, {registry_data}")
-
-    def publish_actions(self, action_id: str, action_info: dict):
-        if self.mqtt_disable:
-            return
-        address = f"labs/{MQConfig.lab_id}/actions/"
-        self.client.publish(address, json.dumps(action_info), qos=2)
-        logger.debug(f"Action data published: address: {address}, {action_id}, {action_info}")
-
-    def send_ping(self, ping_id: str, timestamp: float):
-        """发送ping消息到服务端"""
-        if self.mqtt_disable:
-            return
-        address = f"labs/{MQConfig.lab_id}/ping/"
-        ping_data = {"ping_id": ping_id, "client_timestamp": timestamp, "type": "ping"}
-        self.client.publish(address, json.dumps(ping_data), qos=2)
-
-    def setup_pong_subscription(self):
-        """设置pong消息订阅"""
-        if self.mqtt_disable:
-            return
-        pong_topic = f"labs/{MQConfig.lab_id}/pong/"
-        self.client.subscribe(pong_topic, 0)
-        logger.debug(f"Subscribed to pong topic: {pong_topic}")
-
-    def handle_pong(self, pong_data: dict):
-        """处理pong响应（这个方法会在收到pong消息时被调用）"""
-        logger.debug(f"Pong received: {pong_data}")
-        # 这里会被HostNode的ping-pong处理逻辑调用
-        pass
-
-
-mqtt_client = MQTTClient()
-
-if __name__ == "__main__":
-    mqtt_client.start()

unilabos/app/register.py

@@ -0,0 +1,62 @@
+import argparse
+import json
+import time
+
+from unilabos.config.config import BasicConfig
+from unilabos.registry.registry import build_registry
+
+from unilabos.app.main import load_config_from_file
+from unilabos.utils.log import logger
+from unilabos.utils.type_check import TypeEncoder
+
+
+def register_devices_and_resources(lab_registry):
+    """
+    注册设备和资源到服务器（仅支持HTTP）
+    """
+
+    # 注册资源信息 - 使用HTTP方式
+    from unilabos.app.web.client import http_client
+
+    logger.info("[UniLab Register] 开始注册设备和资源...")
+
+    # 注册设备信息
+    devices_to_register = {}
+    for device_info in lab_registry.obtain_registry_device_info():
+        devices_to_register[device_info["id"]] = json.loads(
+            json.dumps(device_info, ensure_ascii=False, cls=TypeEncoder)
+        )
+        logger.debug(f"[UniLab Register] 收集设备: {device_info['id']}")
+
+    resources_to_register = {}
+    for resource_info in lab_registry.obtain_registry_resource_info():
+        resources_to_register[resource_info["id"]] = resource_info
+        logger.debug(f"[UniLab Register] 收集资源: {resource_info['id']}")
+
+    # 注册设备
+    if devices_to_register:
+        try:
+            start_time = time.time()
+            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}ms")
+            else:
+                logger.error(f"[UniLab Register] 设备注册失败: {response.status_code}, {response.text} {cost_time}ms")
+        except Exception as e:
+            logger.error(f"[UniLab Register] 设备注册异常: {e}")
+
+    # 注册资源
+    if resources_to_register:
+        try:
+            start_time = time.time()
+            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}ms")
+            else:
+                logger.error(f"[UniLab Register] 资源注册失败: {response.status_code}, {response.text} {cost_time}ms")
+        except Exception as e:
+            logger.error(f"[UniLab Register] 资源注册异常: {e}")
+
+    logger.info("[UniLab Register] 设备和资源注册完成.")

unilabos/app/web/client.py

@@ -4,11 +4,13 @@ HTTP客户端模块
 提供与远程服务器通信的客户端功能，只有host需要用
 """
 
+import json
+import os
 from typing import List, Dict, Any, Optional
 
 import requests
 from unilabos.utils.log import info
-from unilabos.config.config import MQConfig, HTTPConfig
+from unilabos.config.config import HTTPConfig, BasicConfig
 from unilabos.utils import logger
 
 
@@ -23,14 +25,17 @@ class HTTPClient:
             remote_addr: 远程服务器地址，如果不提供则从配置中获取
             auth: 授权信息
         """
+        self.initialized = False
         self.remote_addr = remote_addr or HTTPConfig.remote_addr
         if auth is not None:
             self.auth = auth
         else:
-            self.auth = MQConfig.lab_id
+            auth_secret = BasicConfig.auth_secret()
+            self.auth = auth_secret
+            info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
         info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")
 
-    def resource_add(self, resources: List[Dict[str, Any]], database_process_later:bool) -> requests.Response:
+    def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
         """
         添加资源
 
@@ -41,11 +46,52 @@ class HTTPClient:
             Response: API响应对象
         """
         response = requests.post(
-            f"{self.remote_addr}/lab/resource/?database_process_later={1 if database_process_later else 0}",
-            json=resources,
-            headers={"Authorization": f"lab {self.auth}"},
-            timeout=5,
+            f"{self.remote_addr}/lab/material/edge",
+            json={
+                "edges": resources,
+            },
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=100,
         )
+        if response.status_code == 200:
+            res = response.json()
+            if "code" in res and res["code"] != 0:
+                logger.error(f"添加物料关系失败: {response.text}")
+        if response.status_code != 200 and response.status_code != 201:
+            logger.error(f"添加物料关系失败: {response.status_code}, {response.text}")
+        return response
+
+    def resource_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
+        """
+        添加资源
+
+        Args:
+            resources: 要添加的资源列表
+        Returns:
+            Response: API响应对象
+        """
+        if not self.initialized:
+            self.initialized = True
+            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
+            response = requests.post(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        else:
+            response = requests.put(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        if response.status_code == 200:
+            res = response.json()
+            if "code" in res and res["code"] != 0:
+                logger.error(f"添加物料失败: {response.text}")
+        if response.status_code != 200:
+            logger.error(f"添加物料失败: {response.text}")
         return response
 
     def resource_get(self, id: str, with_children: bool = False) -> Dict[str, Any]:
@@ -60,10 +106,10 @@ class HTTPClient:
             Dict: 返回的资源数据
         """
         response = requests.get(
-            f"{self.remote_addr}/lab/resource/?edge_format=1",
+            f"{self.remote_addr}/lab/material",
             params={"id": id, "with_children": with_children},
-            headers={"Authorization": f"lab {self.auth}"},
-            timeout=5,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=20,
         )
         return response.json()
 
@@ -80,8 +126,8 @@ class HTTPClient:
         response = requests.delete(
             f"{self.remote_addr}/lab/resource/batch_delete/",
             params={"id": id},
-            headers={"Authorization": f"lab {self.auth}"},
-            timeout=5,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=20,
         )
         return response
 
@@ -95,13 +141,29 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        response = requests.patch(
-            f"{self.remote_addr}/lab/resource/batch_update/?edge_format=1",
-            json=resources,
-            headers={"Authorization": f"lab {self.auth}"},
-            timeout=5,
-        )
-        return response
+        if not self.initialized:
+            self.initialized = True
+            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
+            response = requests.post(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        else:
+            response = requests.put(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        if response.status_code == 200:
+            res = response.json()
+            if "code" in res and res["code"] != 0:
+                logger.error(f"添加物料失败: {response.text}")
+        if response.status_code != 200:
+            logger.error(f"添加物料失败: {response.text}")
+        return response.json()
 
     def upload_file(self, file_path: str, scene: str = "models") -> requests.Response:
         """
@@ -122,11 +184,61 @@ class HTTPClient:
             response = requests.post(
                 f"{self.remote_addr}/api/account/file_upload/{scene}",
                 files=files,
-                headers={"Authorization": f"lab {self.auth}"},
+                headers={"Authorization": f"Lab {self.auth}"},
                 timeout=30,  # 上传文件可能需要更长的超时时间
             )
         return response
 
+    def resource_registry(self, registry_data: Dict[str, Any] | List[Dict[str, Any]]) -> requests.Response:
+        """
+        注册资源到服务器
+
+        Args:
+            registry_data: 注册表数据，格式为 {resource_id: resource_info} / [{resource_info}]
+
+        Returns:
+            Response: API响应对象
+        """
+        response = requests.post(
+            f"{self.remote_addr}/lab/resource",
+            json=registry_data,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=30,
+        )
+        if response.status_code not in [200, 201]:
+            logger.error(f"注册资源失败: {response.status_code}, {response.text}")
+        return response
+
+    def request_startup_json(self) -> Optional[Dict[str, Any]]:
+        """
+        请求启动配置
+
+        Args:
+            startup_json: 启动配置JSON数据
+
+        Returns:
+            Response: API响应对象
+        """
+        response = requests.get(
+            f"{self.remote_addr}/lab/resource/graph_info/",
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=(3, 30),
+        )
+        if response.status_code != 200:
+            logger.error(f"请求启动配置失败: {response.status_code}, {response.text}")
+        else:
+            try:
+                with open(os.path.join(BasicConfig.working_dir, "startup_config.json"), "w", encoding="utf-8") as f:
+                    f.write(response.text)
+                target_dict = json.loads(response.text)
+                if "data" in target_dict:
+                    target_dict = target_dict["data"]
+                return target_dict
+            except json.JSONDecodeError as e:
+                logger.error(f"解析启动配置JSON失败: {str(e.args)}\n响应内容: {response.text}")
+                logger.error(f"响应内容: {response.text}")
+        return None
+
 
 # 创建默认客户端实例
 http_client = HTTPClient()

unilabos/app/web/controler.py

@@ -0,0 +1,45 @@
+
+import json
+import traceback
+import uuid
+from unilabos.app.model import JobAddReq, JobData
+from unilabos.ros.nodes.presets.host_node import HostNode
+from unilabos.utils.type_check import serialize_result_info
+
+
+def get_resources() -> tuple:
+    if HostNode.get_instance() is None:
+        return False, "Host node not initialized"
+
+    return True, HostNode.get_instance().resources_config
+
+def devices() -> tuple:
+    if HostNode.get_instance() is None:
+        return False, "Host node not initialized"
+    
+    return True, HostNode.get_instance().devices_config
+
+def job_info(id: str):
+    get_goal_status = HostNode.get_instance().get_goal_status(id)
+    return JobData(jobId=id, status=get_goal_status)
+
+def job_add(req: JobAddReq) -> JobData:
+    if req.job_id is None:
+        req.job_id = str(uuid.uuid4())
+    action_name = req.data["action"]
+    action_type = req.data.get("action_type", "LocalUnknown")
+    action_args = req.data.get("action_kwargs", None)  # 兼容老版本，后续删除
+    if action_args is None:
+        action_args = req.data.get("action_args")
+    else:
+        if "command" in action_args:
+            action_args = action_args["command"]
+    # print(f"job_add:{req.device_id} {action_name} {action_kwargs}")
+    try:
+        HostNode.get_instance().send_goal(req.device_id, action_type=action_type, action_name=action_name, action_kwargs=action_args, goal_uuid=req.job_id, server_info=req.server_info)
+    except Exception as e:
+        for bridge in HostNode.get_instance().bridges:
+            traceback.print_exc()
+            if hasattr(bridge, "publish_job_status"):
+                bridge.publish_job_status({}, req.job_id, "failed", serialize_result_info(traceback.format_exc(), False, {}))
+    return JobData(jobId=req.job_id)

unilabos/app/web/pages.py

@@ -7,6 +7,7 @@ Web页面模块
 import json
 import os
 import sys
+import traceback
 from pathlib import Path
 from typing import Dict
 
@@ -16,9 +17,8 @@ from jinja2 import Environment, FileSystemLoader
 
 from unilabos.config.config import BasicConfig
 from unilabos.registry.registry import lab_registry
-from unilabos.app.mq import mqtt_client
 from unilabos.ros.msgs.message_converter import msg_converter_manager
-from unilabos.utils.log import error
+from unilabos.utils.log import error, debug
 from unilabos.utils.type_check import TypeEncoder
 from unilabos.app.web.utils.device_utils import get_registry_info
 from unilabos.app.web.utils.host_utils import get_host_node_info
@@ -78,21 +78,23 @@ def setup_web_pages(router: APIRouter) -> None:
             HTMLResponse: 渲染后的HTML页面
         """
         try:
-            # 准备设备数据
+            # 准备初始数据结构（这些数据将通过WebSocket实时更新）
             devices = []
             resources = []
             modules = {"names": [], "classes": [], "displayed_count": 0, "total_count": 0}
 
-            # 获取在线设备信息
+            # 获取在线设备信息（用于初始渲染）
             ros_node_info = get_ros_node_info()
-            # 获取主机节点信息
+            # 获取主机节点信息（用于初始渲染）
             host_node_info = get_host_node_info()
-            # 获取Registry路径信息
+            # 获取Registry路径信息（静态信息，不需要实时更新）
             registry_info = get_registry_info()
 
-            # 获取已加载的设备
+            # 获取初始数据用于页面渲染（后续将被WebSocket数据覆盖）
             if lab_registry:
-                devices = json.loads(json.dumps(lab_registry.obtain_registry_device_info(), ensure_ascii=False, cls=TypeEncoder))
+                devices = json.loads(
+                    json.dumps(lab_registry.obtain_registry_device_info(), ensure_ascii=False, cls=TypeEncoder)
+                )
                 # 资源类型
                 for resource_id, resource_info in lab_registry.resource_type_registry.items():
                     resources.append(
@@ -103,7 +105,7 @@ def setup_web_pages(router: APIRouter) -> None:
                         }
                     )
 
-            # 获取导入的模块
+            # 获取导入的模块（初始数据）
             if msg_converter_manager:
                 modules["names"] = msg_converter_manager.list_modules()
                 all_classes = [i for i in msg_converter_manager.list_classes() if "." in i]
@@ -124,6 +126,7 @@ def setup_web_pages(router: APIRouter) -> None:
 
             return html
         except Exception as e:
+            debug(traceback.format_exc())
             error(f"生成状态页面时出错: {str(e)}")
             raise HTTPException(status_code=500, detail=f"Error generating status page: {str(e)}")
 
@@ -170,3 +173,20 @@ def setup_web_pages(router: APIRouter) -> None:
         except Exception as e:
             error(f"打开文件夹时出错: {str(e)}")
             return {"status": "error", "message": f"Failed to open folder: {str(e)}"}
+
+    @router.get("/registry-editor", response_class=HTMLResponse, summary="Registry Editor")
+    async def registry_editor_page() -> str:
+        """
+        注册表编辑页面，用于导入Python文件并生成注册表
+
+        Returns:
+            HTMLResponse: 渲染后的HTML页面
+        """
+        try:
+            # 使用模板渲染页面
+            template = env.get_template("registry_editor.html")
+            html = template.render()
+            return html
+        except Exception as e:
+            error(f"生成注册表编辑页面时出错: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error generating registry editor page: {str(e)}")

unilabos/app/web/templates/base.html

@@ -162,7 +162,6 @@
 <body>
     <h1>{% block header %}UniLab{% endblock %}</h1>
     {% block nav %}
-    <a href="/unilabos/webtic" class="home-link">Home</a>
     {% endblock %}
 
     {% block top_info %}{% endblock %}

unilabos/app/web/templates/home.html

@@ -1,22 +1,25 @@
-{% extends "base.html" %}
-
-{% block title %}UniLab API{% endblock %}
-
-{% block header %}UniLab API{% endblock %}
-
-{% block nav %}
-<a href="/status" class="status-link">System Status</a>
-{% endblock %}
-
-{% block content %}
+{% extends "base.html" %} {% block title %}UniLab API{% endblock %} {% block
+header %}UniLab API{% endblock %} {% block nav %}
+<div class="nav-tabs">
+  <a
+    href="/"
+    class="nav-tab"
+    style="background-color: #2196f3; color: white"
+    target="_blank"
+    >主页</a
+  >
+  <a href="/status" class="nav-tab">状态</a>
+  <a href="/registry-editor" class="nav-tab" target="_blank">注册表编辑</a>
+</div>
+{% endblock %} {% block content %}
 <div class="card">
-    <h2>Available Endpoints</h2>
-    {% for route in routes %}
-    <div class="endpoint">
-        <span class="method">{{ route.method }}</span>
-        <a href="{{ route.path }}">{{ route.path }}</a>
-        <p>{{ route.summary }}</p>
-    </div>
-    {% endfor %}
+  <h2>Available Endpoints</h2>
+  {% for route in routes %}
+  <div class="endpoint">
+    <span class="method">{{ route.method }}</span>
+    <a href="{{ route.path }}">{{ route.path }}</a>
+    <p>{{ route.summary }}</p>
+  </div>
+  {% endfor %}
 </div>
 {% endblock %}

unilabos/app/web/utils/action_utils.py

@@ -65,6 +65,8 @@ def get_yaml_from_goal_type(goal_type) -> str:
     Returns:
         str: 默认Goal参数的YAML格式字符串
     """
+    if isinstance(goal_type, str):
+        return "{}"
     if not goal_type:
         return "{}"
 

unilabos/compile/__init__.py

@@ -8,37 +8,51 @@ from .agv_transfer_protocol import generate_agv_transfer_protocol
 from .add_protocol import generate_add_protocol
 from .centrifuge_protocol import generate_centrifuge_protocol
 from .filter_protocol import generate_filter_protocol
-from .heatchill_protocol import generate_heat_chill_protocol, generate_heat_chill_start_protocol, generate_heat_chill_stop_protocol
+from .heatchill_protocol import (
+    generate_heat_chill_protocol, 
+    generate_heat_chill_start_protocol, 
+    generate_heat_chill_stop_protocol,
+    generate_heat_chill_to_temp_protocol  # 保留导入，但不注册为协议
+)
 from .stir_protocol import generate_stir_protocol, generate_start_stir_protocol, generate_stop_stir_protocol
-from .transfer_protocol import generate_transfer_protocol
 from .clean_vessel_protocol import generate_clean_vessel_protocol
 from .dissolve_protocol import generate_dissolve_protocol
 from .filter_through_protocol import generate_filter_through_protocol
 from .run_column_protocol import generate_run_column_protocol
 from .wash_solid_protocol import generate_wash_solid_protocol
+from .adjustph_protocol import generate_adjust_ph_protocol
+from .reset_handling_protocol import generate_reset_handling_protocol
+from .dry_protocol import generate_dry_protocol
+from .recrystallize_protocol import generate_recrystallize_protocol
+from .hydrogenate_protocol import generate_hydrogenate_protocol
 
 
 # Define a dictionary of protocol generators.
 action_protocol_generators = {
-    PumpTransferProtocol: generate_pump_protocol_with_rinsing,
-    CleanProtocol: generate_clean_protocol,
-    SeparateProtocol: generate_separate_protocol,
-    EvaporateProtocol: generate_evaporate_protocol,
-    EvacuateAndRefillProtocol: generate_evacuateandrefill_protocol,
-    AGVTransferProtocol: generate_agv_transfer_protocol,
-    CentrifugeProtocol: generate_centrifuge_protocol,
     AddProtocol: generate_add_protocol,
+    AGVTransferProtocol: generate_agv_transfer_protocol,
+    AdjustPHProtocol: generate_adjust_ph_protocol,
+    CentrifugeProtocol: generate_centrifuge_protocol,
+    CleanProtocol: generate_clean_protocol,
+    CleanVesselProtocol: generate_clean_vessel_protocol,
+    DissolveProtocol: generate_dissolve_protocol,
+    DryProtocol: generate_dry_protocol,
+    EvacuateAndRefillProtocol: generate_evacuateandrefill_protocol,
+    EvaporateProtocol: generate_evaporate_protocol,
     FilterProtocol: generate_filter_protocol,
+    FilterThroughProtocol: generate_filter_through_protocol,
     HeatChillProtocol: generate_heat_chill_protocol,
     HeatChillStartProtocol: generate_heat_chill_start_protocol,
     HeatChillStopProtocol: generate_heat_chill_stop_protocol,
-    StirProtocol: generate_stir_protocol,
-    StartStirProtocol: generate_start_stir_protocol,
-    StopStirProtocol: generate_stop_stir_protocol,
-    TransferProtocol: generate_transfer_protocol,
-    CleanVesselProtocol: generate_clean_vessel_protocol,
-    DissolveProtocol: generate_dissolve_protocol,
-    FilterThroughProtocol: generate_filter_through_protocol,
+    HydrogenateProtocol: generate_hydrogenate_protocol,
+    PumpTransferProtocol: generate_pump_protocol_with_rinsing,
+    TransferProtocol: generate_pump_protocol,
+    RecrystallizeProtocol: generate_recrystallize_protocol,
+    ResetHandlingProtocol: generate_reset_handling_protocol,
     RunColumnProtocol: generate_run_column_protocol,
+    SeparateProtocol: generate_separate_protocol,
+    StartStirProtocol: generate_start_stir_protocol,
+    StirProtocol: generate_stir_protocol,
+    StopStirProtocol: generate_stop_stir_protocol,
     WashSolidProtocol: generate_wash_solid_protocol,
 }

unilabos/compile/add_protocol.py

@@ -1,74 +1,423 @@
+from functools import partial
+
 import networkx as nx
-from typing import List, Dict, Any  
+import re
+import logging
+from typing import List, Dict, Any, Union
+
+from .utils.unit_parser import parse_volume_input, parse_mass_input, parse_time_input
+from .utils.vessel_parser import get_vessel, find_solid_dispenser, find_connected_stirrer, find_reagent_vessel
+from .utils.logger_util import action_log
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[ADD] {message}")
+
+
+# 🆕 创建进度日志动作
+create_action_log = partial(action_log, prefix="[ADD]")
 
 def generate_add_protocol(
     G: nx.DiGraph,
-    vessel: str,  
+    vessel: dict,  # 🔧 修改：现在接收字典类型的 vessel
     reagent: str,
-    volume: float,  
-    mass: float,  
-    amount: str,  
-    time: float,  
-    stir: bool,  
-    stir_speed: float,  
-    viscous: bool,  
-    purpose: str  
+    # 🔧 修复：所有参数都用 Union 类型，支持字符串和数值
+    volume: Union[str, float] = 0.0,
+    mass: Union[str, float] = 0.0,
+    amount: str = "",
+    time: Union[str, float] = 0.0,
+    stir: bool = False,
+    stir_speed: float = 300.0,
+    viscous: bool = False,
+    purpose: str = "添加试剂",
+    # XDL扩展参数
+    mol: str = "",
+    event: str = "",
+    rate_spec: str = "",
+    equiv: str = "",
+    ratio: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成添加试剂的协议序列 - 严格按照 Add.action
+    生成添加试剂协议 - 修复版
+    
+    支持所有XDL参数和单位：
+    - vessel: Resource类型字典，包含id字段
+    - volume: "2.7 mL", "2.67 mL", "?" 或数值
+    - mass: "19.3 g", "4.5 g" 或数值
+    - time: "1 h", "20 min" 或数值（秒）
+    - mol: "0.28 mol", "16.2 mmol", "25.2 mmol"
+    - rate_spec: "portionwise", "dropwise"
+    - event: "A", "B"
+    - equiv: "1.1"
+    - ratio: "?", "1:1"
     """
+
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    # 🔧 修改：更新容器的液体体积（假设有 liquid_volume 字段）
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        if isinstance(vessel["data"]["liquid_volume"], list) and len(vessel["data"]["liquid_volume"]) > 0:
+            vessel["data"]["liquid_volume"][0] -= parse_volume_input(volume)
+    
+    debug_print("=" * 60)
+    debug_print("🚀 开始生成添加试剂协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🧪 reagent: '{reagent}'")
+    debug_print(f"  📏 volume: {volume} (类型: {type(volume)})")
+    debug_print(f"  ⚖️ mass: {mass} (类型: {type(mass)})")
+    debug_print(f"  ⏱️ time: {time} (类型: {type(time)})")
+    debug_print(f"  🧬 mol: '{mol}'")
+    debug_print(f"  🎯 event: '{event}'")
+    debug_print(f"  ⚡ rate_spec: '{rate_spec}'")
+    debug_print(f"  🌪️ stir: {stir}")
+    debug_print(f"  🔄 stir_speed: {stir_speed} rpm")
+    debug_print("=" * 60)
+    
     action_sequence = []
     
-    # 如果指定了体积，执行液体转移  
-    if volume > 0:  
-        # 查找可用的试剂瓶
-        available_flasks = [node for node in G.nodes() 
-                           if node.startswith('flask_') 
-                           and G.nodes[node].get('type') == 'container']
+    # === 参数验证 ===
+    debug_print("🔍 步骤1: 参数验证...")
+    action_sequence.append(create_action_log(f"开始添加试剂 '{reagent}' 到容器 '{vessel_id}'", "🎬"))
     
-        if not available_flasks:
-            raise ValueError("没有找到可用的试剂容器")
+    if not vessel or not vessel_id:
+        debug_print("❌ vessel 参数不能为空")
+        raise ValueError("vessel 参数不能为空")
+    if not reagent:
+        debug_print("❌ reagent 参数不能为空")
+        raise ValueError("reagent 参数不能为空")
     
-        reagent_vessel = available_flasks[0]
+    if vessel_id not in G.nodes():
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中")
+        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
     
-        # 查找泵设备
-        pump_nodes = [node for node in G.nodes() 
-                     if G.nodes[node].get('class') == 'virtual_pump']
+    debug_print("✅ 基本参数验证通过")
     
-        if pump_nodes:
-            pump_id = pump_nodes[0]
-            action_sequence.append({
-                "device_id": pump_id,
-                "action_name": "transfer",
-                "action_kwargs": {
-                    "from_vessel": reagent_vessel,
-                    "to_vessel": vessel,
-                    "volume": volume,
-                    "amount": amount,
-                    "time": time,
-                    "viscous": viscous,
-                    "rinsing_solvent": "",
-                    "rinsing_volume": 0.0,
-                    "rinsing_repeats": 0,
-                    "solid": False
+    # === 🔧 关键修复：参数解析 ===
+    debug_print("🔍 步骤2: 参数解析...")
+    action_sequence.append(create_action_log("正在解析添加参数...", "🔍"))
+    
+    # 解析各种参数为数值
+    final_volume = parse_volume_input(volume)
+    final_mass = parse_mass_input(mass)
+    final_time = parse_time_input(time)
+    
+    debug_print(f"📊 解析结果:")
+    debug_print(f"  体积: {final_volume}mL, 质量: {final_mass}g, 时间: {final_time}s, 摩尔: '{mol}', 事件: '{event}', 速率: '{rate_spec}'")
+    
+    # === 判断添加类型 ===
+    debug_print("🔍 步骤3: 判断添加类型...")
+    
+    # 🔧 修复：现在使用解析后的数值进行比较
+    is_solid = (final_mass > 0 or (mol and mol.strip() != ""))
+    is_liquid = (final_volume > 0)
+    
+    if not is_solid and not is_liquid:
+        # 默认为液体，10mL
+        is_liquid = True
+        final_volume = 10.0
+        debug_print("⚠️ 未指定体积或质量，默认为10mL液体")
+    
+    add_type = "固体" if is_solid else "液体"
+    add_emoji = "🧂" if is_solid else "💧"
+    debug_print(f"📋 添加类型: {add_type} {add_emoji}")
+    
+    action_sequence.append(create_action_log(f"确定添加类型: {add_type} {add_emoji}", "📋"))
+    
+    # === 执行添加流程 ===
+    debug_print("🔍 步骤4: 执行添加流程...")
+    
+    try:
+        if is_solid:
+            # === 固体添加路径 ===
+            debug_print(f"🧂 使用固体添加路径")
+            action_sequence.append(create_action_log("开始固体试剂添加流程", "🧂"))
+            
+            solid_dispenser = find_solid_dispenser(G)
+            if solid_dispenser:
+                action_sequence.append(create_action_log(f"找到固体加样器: {solid_dispenser}", "🥄"))
+                
+                # 启动搅拌
+                if stir:
+                    debug_print("🌪️ 准备启动搅拌...")
+                    action_sequence.append(create_action_log("准备启动搅拌器", "🌪️"))
+                    
+                    stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
+                    if stirrer_id:
+                        action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed} rpm)", "🔄"))
+                        
+                        action_sequence.append({
+                            "device_id": stirrer_id,
+                            "action_name": "start_stir",
+                            "action_kwargs": {
+                                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                                "stir_speed": stir_speed,
+                                "purpose": f"准备添加固体 {reagent}"
+                            }
+                        })
+                        # 等待搅拌稳定
+                        action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
+                        action_sequence.append({
+                            "action_name": "wait",
+                            "action_kwargs": {"time": 3}
+                        })
+                
+                # 固体加样
+                add_kwargs = {
+                    "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                    "reagent": reagent,
+                    "purpose": purpose,
+                    "event": event,
+                    "rate_spec": rate_spec
                 }
-            })
                 
-    # 如果需要搅拌，使用 StartStir 而不是 Stir  
-    if stir:  
-        stirrer_nodes = [node for node in G.nodes()   
-                        if G.nodes[node].get('class') == 'virtual_stirrer']  
+                if final_mass > 0:
+                    add_kwargs["mass"] = str(final_mass)
+                    action_sequence.append(create_action_log(f"准备添加固体: {final_mass}g", "⚖️"))
+                if mol and mol.strip():
+                    add_kwargs["mol"] = mol
+                    action_sequence.append(create_action_log(f"按摩尔数添加: {mol}", "🧬"))
+                if equiv and equiv.strip():
+                    add_kwargs["equiv"] = equiv
+                    action_sequence.append(create_action_log(f"当量: {equiv}", "🔢"))
                 
-        if stirrer_nodes:  
-            stirrer_id = stirrer_nodes[0]  
-            action_sequence.append({  
-                "device_id": stirrer_id,  
-                "action_name": "start_stir",  # 使用 start_stir 而不是 stir
-                "action_kwargs": {  
-                    "vessel": vessel,
-                    "stir_speed": stir_speed,
-                    "purpose": f"添加 {reagent} 后搅拌"
-                }  
-            })  
+                action_sequence.append(create_action_log("开始固体加样操作", "🥄"))
+                action_sequence.append({
+                    "device_id": solid_dispenser,
+                    "action_name": "add_solid",
+                    "action_kwargs": add_kwargs
+                })
+                
+                action_sequence.append(create_action_log("固体加样完成", "✅"))
+                
+                # 添加后等待
+                if final_time > 0:
+                    wait_minutes = final_time / 60
+                    action_sequence.append(create_action_log(f"等待反应进行 ({wait_minutes:.1f}分钟)", "⏰"))
+                    action_sequence.append({
+                        "action_name": "wait",
+                        "action_kwargs": {"time": final_time}
+                    })
+                    
+                debug_print(f"✅ 固体添加完成")
+            else:
+                debug_print("❌ 未找到固体加样器，跳过固体添加")
+                action_sequence.append(create_action_log("未找到固体加样器，无法添加固体", "❌"))
+        
+        else:
+            # === 液体添加路径 ===
+            debug_print(f"💧 使用液体添加路径")
+            action_sequence.append(create_action_log("开始液体试剂添加流程", "💧"))
+            
+            # 查找试剂容器
+            action_sequence.append(create_action_log("正在查找试剂容器...", "🔍"))
+            reagent_vessel = find_reagent_vessel(G, reagent)
+            action_sequence.append(create_action_log(f"找到试剂容器: {reagent_vessel}", "🧪"))
+            
+            # 启动搅拌
+            if stir:
+                debug_print("🌪️ 准备启动搅拌...")
+                action_sequence.append(create_action_log("准备启动搅拌器", "🌪️"))
+                
+                stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
+                if stirrer_id:
+                    action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed} rpm)", "🔄"))
+                    
+                    action_sequence.append({
+                        "device_id": stirrer_id,
+                        "action_name": "start_stir",
+                        "action_kwargs": {
+                            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                            "stir_speed": stir_speed,
+                            "purpose": f"准备添加液体 {reagent}"
+                        }
+                    })
+                    # 等待搅拌稳定
+                    action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
+                    action_sequence.append({
+                        "action_name": "wait",
+                        "action_kwargs": {"time": 5}
+                    })
+            
+            # 计算流速
+            if final_time > 0:
+                flowrate = final_volume / final_time * 60  # mL/min
+                transfer_flowrate = flowrate
+                debug_print(f"⚡ 根据时间计算流速: {flowrate:.2f} mL/min")
+            else:
+                if rate_spec == "dropwise":
+                    flowrate = 0.5  # 滴加，很慢
+                    transfer_flowrate = 0.2
+                    debug_print(f"💧 滴加模式，流速: {flowrate} mL/min")
+                elif viscous:
+                    flowrate = 1.0  # 粘性液体
+                    transfer_flowrate = 0.3
+                    debug_print(f"🍯 粘性液体，流速: {flowrate} mL/min")
+                else:
+                    flowrate = 2.5  # 正常流速
+                    transfer_flowrate = 0.5
+                    debug_print(f"⚡ 正常流速: {flowrate} mL/min")
+            
+            action_sequence.append(create_action_log(f"设置流速: {flowrate:.2f} mL/min", "⚡"))
+            action_sequence.append(create_action_log(f"开始转移 {final_volume}mL 液体", "🚰"))
+            
+            # 调用pump protocol
+            pump_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=reagent_vessel,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
+                volume=final_volume,
+                amount=amount,
+                time=final_time,
+                viscous=viscous,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=flowrate,
+                transfer_flowrate=transfer_flowrate,
+                rate_spec=rate_spec,
+                event=event,
+                through="",
+                **kwargs
+            )
+            action_sequence.extend(pump_actions)
+            debug_print(f"✅ 液体转移完成，添加了 {len(pump_actions)} 个动作")
+            action_sequence.append(create_action_log(f"液体转移完成 ({len(pump_actions)} 个操作)", "✅"))
+            
+    except Exception as e:
+        debug_print(f"❌ 试剂添加失败: {str(e)}")
+        action_sequence.append(create_action_log(f"试剂添加失败: {str(e)}", "❌"))
+        # 添加错误日志
+        action_sequence.append({
+            "device_id": "system",
+            "action_name": "log_message",
+            "action_kwargs": {
+                "message": f"试剂 '{reagent}' 添加失败: {str(e)}"
+            }
+        })
+    
+    # === 最终结果 ===
+    debug_print("=" * 60)
+    debug_print(f"🎉 添加试剂协议生成完成")
+    debug_print(f"📊 总动作数: {len(action_sequence)}")
+    debug_print(f"📋 处理总结:")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  {add_emoji} 添加类型: {add_type}")
+    debug_print(f"  🥼 目标容器: {vessel_id}")
+    if is_liquid:
+        debug_print(f"  📏 体积: {final_volume}mL")
+    if is_solid:
+        debug_print(f"  ⚖️ 质量: {final_mass}g")
+        debug_print(f"  🧬 摩尔: {mol}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"试剂添加协议完成: {reagent} → {vessel_id}"
+    if is_liquid:
+        summary_msg += f" ({final_volume}mL)"
+    if is_solid:
+        summary_msg += f" ({final_mass}g)"
+    
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
     
     return action_sequence
+
+# === 便捷函数 ===
+# 🔧 修改便捷函数的参数类型
+
+def add_liquid_volume(G: nx.DiGraph, vessel: dict, reagent: str, volume: Union[str, float], 
+                     time: Union[str, float] = 0.0, rate_spec: str = "") -> List[Dict[str, Any]]:
+    """添加指定体积的液体试剂"""
+    vessel_id = vessel["id"]
+    debug_print(f"💧 快速添加液体: {reagent} ({volume}) → {vessel_id}")
+    return generate_add_protocol(
+        G, vessel, reagent, 
+        volume=volume, 
+        time=time, 
+        rate_spec=rate_spec
+    )
+
+def add_solid_mass(G: nx.DiGraph, vessel: dict, reagent: str, mass: Union[str, float], 
+                   event: str = "") -> List[Dict[str, Any]]:
+    """添加指定质量的固体试剂"""
+    vessel_id = vessel["id"]
+    debug_print(f"🧂 快速添加固体: {reagent} ({mass}) → {vessel_id}")
+    return generate_add_protocol(
+        G, vessel, reagent, 
+        mass=mass, 
+        event=event
+    )
+
+def add_solid_moles(G: nx.DiGraph, vessel: dict, reagent: str, mol: str, 
+                    event: str = "") -> List[Dict[str, Any]]:
+    """按摩尔数添加固体试剂"""
+    vessel_id = vessel["id"]
+    debug_print(f"🧬 按摩尔数添加固体: {reagent} ({mol}) → {vessel_id}")
+    return generate_add_protocol(
+        G, vessel, reagent, 
+        mol=mol, 
+        event=event
+    )
+
+def add_dropwise_liquid(G: nx.DiGraph, vessel: dict, reagent: str, volume: Union[str, float], 
+                        time: Union[str, float] = "20 min", event: str = "") -> List[Dict[str, Any]]:
+    """滴加液体试剂"""
+    vessel_id = vessel["id"]
+    debug_print(f"💧 滴加液体: {reagent} ({volume}) → {vessel_id} (用时: {time})")
+    return generate_add_protocol(
+        G, vessel, reagent, 
+        volume=volume, 
+        time=time, 
+        rate_spec="dropwise", 
+        event=event
+    )
+
+def add_portionwise_solid(G: nx.DiGraph, vessel: dict, reagent: str, mass: Union[str, float], 
+                          time: Union[str, float] = "1 h", event: str = "") -> List[Dict[str, Any]]:
+    """分批添加固体试剂"""
+    vessel_id = vessel["id"]
+    debug_print(f"🧂 分批添加固体: {reagent} ({mass}) → {vessel_id} (用时: {time})")
+    return generate_add_protocol(
+        G, vessel, reagent, 
+        mass=mass, 
+        time=time, 
+        rate_spec="portionwise", 
+        event=event
+    )
+
+# 测试函数
+def test_add_protocol():
+    """测试添加协议的各种参数解析"""
+    print("=== ADD PROTOCOL 增强版测试 ===")
+    
+    # 测试体积解析
+    debug_print("🧪 测试体积解析...")
+    volumes = ["2.7 mL", "2.67 mL", "?", 10.0, "1 L", "500 μL"]
+    for vol in volumes:
+        result = parse_volume_input(vol)
+        print(f"📏 体积解析: {vol} → {result}mL")
+    
+    # 测试质量解析
+    debug_print("⚖️ 测试质量解析...")
+    masses = ["19.3 g", "4.5 g", 2.5, "500 mg", "1 kg"]
+    for mass in masses:
+        result = parse_mass_input(mass)
+        print(f"⚖️ 质量解析: {mass} → {result}g")
+    
+    # 测试时间解析
+    debug_print("⏱️ 测试时间解析...")
+    times = ["1 h", "20 min", "30 s", 60.0, "?"]
+    for time in times:
+        result = parse_time_input(time)
+        print(f"⏱️ 时间解析: {time} → {result}s")
+    
+    print("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_add_protocol()

unilabos/compile/adjustph_protocol.py

@@ -0,0 +1,632 @@
+import networkx as nx
+import logging
+from typing import List, Dict, Any, Union
+from .utils.vessel_parser import get_vessel
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[ADJUST_PH] {message}")
+
+def find_acid_base_vessel(G: nx.DiGraph, reagent: str) -> str:
+    """
+    查找酸碱试剂容器，支持多种匹配模式
+    
+    Args:
+        G: 网络图
+        reagent: 试剂名称（如 "hydrochloric acid", "sodium hydroxide"）
+    
+    Returns:
+        str: 试剂容器ID
+    """
+    debug_print(f"🔍 正在查找试剂 '{reagent}' 的容器...")
+    
+    # 常见酸碱试剂的别名映射
+    reagent_aliases = {
+        "hydrochloric acid": ["HCl", "hydrochloric_acid", "hcl", "muriatic_acid"],
+        "sodium hydroxide": ["NaOH", "sodium_hydroxide", "naoh", "caustic_soda"],
+        "sulfuric acid": ["H2SO4", "sulfuric_acid", "h2so4"],
+        "nitric acid": ["HNO3", "nitric_acid", "hno3"],
+        "acetic acid": ["CH3COOH", "acetic_acid", "glacial_acetic_acid"],
+        "ammonia": ["NH3", "ammonium_hydroxide", "nh3"],
+        "potassium hydroxide": ["KOH", "potassium_hydroxide", "koh"]
+    }
+    
+    # 构建搜索名称列表
+    search_names = [reagent.lower()]
+    debug_print(f"📋 基础搜索名称: {reagent.lower()}")
+    
+    # 添加别名
+    for base_name, aliases in reagent_aliases.items():
+        if reagent.lower() in base_name.lower() or base_name.lower() in reagent.lower():
+            search_names.extend([alias.lower() for alias in aliases])
+            debug_print(f"🔗 添加别名: {aliases}")
+            break
+    
+    debug_print(f"📝 完整搜索列表: {search_names}")
+    
+    # 构建可能的容器名称
+    possible_names = []
+    for name in search_names:
+        name_clean = name.replace(" ", "_").replace("-", "_")
+        possible_names.extend([
+            f"flask_{name_clean}",
+            f"bottle_{name_clean}",
+            f"reagent_{name_clean}",
+            f"acid_{name_clean}" if "acid" in name else f"base_{name_clean}",
+            f"{name_clean}_bottle",
+            f"{name_clean}_flask",
+            name_clean
+        ])
+    
+    debug_print(f"🎯 可能的容器名称 (前5个): {possible_names[:5]}... (共{len(possible_names)}个)")
+    
+    # 第一步：通过容器名称匹配
+    debug_print(f"📋 方法1: 精确名称匹配...")
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            debug_print(f"✅ 通过名称匹配找到容器: {vessel_name} 🎯")
+            return vessel_name
+    
+    # 第二步：通过模糊匹配
+    debug_print(f"📋 方法2: 模糊名称匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            node_name = G.nodes[node_id].get('name', '').lower()
+            
+            # 检查是否包含任何搜索名称
+            for search_name in search_names:
+                if search_name in node_id.lower() or search_name in node_name:
+                    debug_print(f"✅ 通过模糊匹配找到容器: {node_id} 🔍")
+                    return node_id
+    
+    # 第三步：通过液体类型匹配
+    debug_print(f"📋 方法3: 液体类型匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            
+            for liquid in liquids:
+                if isinstance(liquid, dict):
+                    liquid_type = (liquid.get('liquid_type') or liquid.get('name', '')).lower()
+                    reagent_name = vessel_data.get('reagent_name', '').lower()
+                    
+                    for search_name in search_names:
+                        if search_name in liquid_type or search_name in reagent_name:
+                            debug_print(f"✅ 通过液体类型匹配找到容器: {node_id} 💧")
+                            return node_id
+    
+    # 列出可用容器帮助调试
+    debug_print(f"📊 列出可用容器帮助调试...")
+    available_containers = []
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            liquid_types = [liquid.get('liquid_type', '') or liquid.get('name', '') 
+                           for liquid in liquids if isinstance(liquid, dict)]
+            
+            available_containers.append({
+                'id': node_id,
+                'name': G.nodes[node_id].get('name', ''),
+                'liquids': liquid_types,
+                'reagent_name': vessel_data.get('reagent_name', '')
+            })
+    
+    debug_print(f"📋 可用容器列表:")
+    for container in available_containers:
+        debug_print(f"  - 🧪 {container['id']}: {container['name']}")
+        debug_print(f"    💧 液体: {container['liquids']}")
+        debug_print(f"    🏷️ 试剂: {container['reagent_name']}")
+    
+    debug_print(f"❌ 所有匹配方法都失败了")
+    raise ValueError(f"找不到试剂 '{reagent}' 对应的容器。尝试了: {possible_names[:10]}...")
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> str:
+    """查找与容器相连的搅拌器"""
+    debug_print(f"🔍 查找连接到容器 '{vessel}' 的搅拌器...")
+    
+    stirrer_nodes = [node for node in G.nodes() 
+                    if (G.nodes[node].get('class') or '') == 'virtual_stirrer']
+    
+    debug_print(f"📊 发现 {len(stirrer_nodes)} 个搅拌器: {stirrer_nodes}")
+    
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer} 🔗")
+            return stirrer
+    
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个: {stirrer_nodes[0]} 🔄")
+        return stirrer_nodes[0]
+    
+    debug_print(f"❌ 未找到任何搅拌器")
+    return None
+
+def calculate_reagent_volume(target_ph_value: float, reagent: str, vessel_volume: float = 100.0) -> float:
+    """
+    估算需要的试剂体积来调节pH
+    
+    Args:
+        target_ph_value: 目标pH值
+        reagent: 试剂名称
+        vessel_volume: 容器体积 (mL)
+    
+    Returns:
+        float: 估算的试剂体积 (mL)
+    """
+    debug_print(f"🧮 计算试剂体积...")
+    debug_print(f"  📍 目标pH: {target_ph_value}")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 容器体积: {vessel_volume}mL")
+    
+    # 简化的pH调节体积估算（实际应用中需要更精确的计算）
+    if "acid" in reagent.lower() or "hcl" in reagent.lower():
+        debug_print(f"🍋 检测到酸性试剂")
+        # 酸性试剂：pH越低需要的体积越大
+        if target_ph_value < 3:
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强酸性 (pH<3): 使用 5% 体积")
+        elif target_ph_value < 5:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中酸性 (pH<5): 使用 2% 体积")
+        else:
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱酸性 (pH≥5): 使用 1% 体积")
+    
+    elif "hydroxide" in reagent.lower() or "naoh" in reagent.lower():
+        debug_print(f"🧂 检测到碱性试剂")
+        # 碱性试剂：pH越高需要的体积越大
+        if target_ph_value > 11:
+            volume = vessel_volume * 0.05  # 5%
+            debug_print(f"  💪 强碱性 (pH>11): 使用 5% 体积")
+        elif target_ph_value > 9:
+            volume = vessel_volume * 0.02  # 2%
+            debug_print(f"  🔸 中碱性 (pH>9): 使用 2% 体积")
+        else:
+            volume = vessel_volume * 0.01  # 1%
+            debug_print(f"  🔹 弱碱性 (pH≤9): 使用 1% 体积")
+    
+    else:
+        # 未知试剂，使用默认值
+        volume = vessel_volume * 0.01
+        debug_print(f"❓ 未知试剂类型，使用默认 1% 体积")
+    
+    debug_print(f"📊 计算结果: {volume:.2f}mL")
+    return volume
+
+def generate_adjust_ph_protocol(
+    G: nx.DiGraph,
+    vessel:Union[dict,str],  # 🔧 修改：从字符串改为字典类型
+    ph_value: float,
+    reagent: str,
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """
+    生成调节pH的协议序列
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（需要调节pH的容器）
+        ph_value: 目标pH值（从XDL传入）
+        reagent: 酸碱试剂名称（从XDL传入）
+        **kwargs: 其他可选参数，使用默认值
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    if not vessel_id:
+        debug_print(f"❌ vessel 参数无效，必须包含id字段或直接提供容器ID. vessel: {vessel}")
+        raise ValueError("vessel 参数无效，必须包含id字段或直接提供容器ID")
+    
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成pH调节协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: '{reagent}'")
+    debug_print(f"  📦 kwargs: {kwargs}")
+    debug_print("=" * 60)
+    
+    action_sequence = []
+    
+    # 从kwargs中获取可选参数，如果没有则使用默认值
+    volume = kwargs.get('volume', 0.0)           # 自动估算体积
+    stir = kwargs.get('stir', True)              # 默认搅拌
+    stir_speed = kwargs.get('stir_speed', 300.0) # 默认搅拌速度
+    stir_time = kwargs.get('stir_time', 60.0)    # 默认搅拌时间
+    settling_time = kwargs.get('settling_time', 30.0)  # 默认平衡时间
+    
+    debug_print(f"🔧 处理后的参数:")
+    debug_print(f"  📏 volume: {volume}mL (0.0表示自动估算)")
+    debug_print(f"  🌪️ stir: {stir}")
+    debug_print(f"  🔄 stir_speed: {stir_speed}rpm")
+    debug_print(f"  ⏱️ stir_time: {stir_time}s")
+    debug_print(f"  ⏳ settling_time: {settling_time}s")
+    
+    # 开始处理
+    action_sequence.append(create_action_log(f"开始调节pH至 {ph_value}", "🧪"))
+    action_sequence.append(create_action_log(f"目标容器: {vessel_id}", "🥼"))
+    action_sequence.append(create_action_log(f"使用试剂: {reagent}", "⚗️"))
+    
+    # 1. 验证目标容器存在
+    debug_print(f"🔍 步骤1: 验证目标容器...")
+    if vessel_id not in G.nodes():
+        debug_print(f"❌ 目标容器 '{vessel_id}' 不存在于系统中")
+        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
+    
+    debug_print(f"✅ 目标容器验证通过")
+    action_sequence.append(create_action_log("目标容器验证通过", "✅"))
+    
+    # 2. 查找酸碱试剂容器
+    debug_print(f"🔍 步骤2: 查找试剂容器...")
+    action_sequence.append(create_action_log("正在查找试剂容器...", "🔍"))
+    
+    try:
+        reagent_vessel = find_acid_base_vessel(G, reagent)
+        debug_print(f"✅ 找到试剂容器: {reagent_vessel}")
+        action_sequence.append(create_action_log(f"找到试剂容器: {reagent_vessel}", "🧪"))
+    except ValueError as e:
+        debug_print(f"❌ 无法找到试剂容器: {str(e)}")
+        action_sequence.append(create_action_log(f"试剂容器查找失败: {str(e)}", "❌"))
+        raise ValueError(f"无法找到试剂 '{reagent}': {str(e)}")
+    
+    # 3. 体积估算
+    debug_print(f"🔍 步骤3: 体积处理...")
+    if volume <= 0:
+        action_sequence.append(create_action_log("开始自动估算试剂体积", "🧮"))
+        
+        # 获取目标容器的体积信息
+        vessel_data = G.nodes[vessel_id].get('data', {})
+        vessel_volume = vessel_data.get('max_volume', 100.0)  # 默认100mL
+        debug_print(f"📏 容器最大体积: {vessel_volume}mL")
+        
+        estimated_volume = calculate_reagent_volume(ph_value, reagent, vessel_volume)
+        volume = estimated_volume
+        debug_print(f"✅ 自动估算试剂体积: {volume:.2f} mL")
+        action_sequence.append(create_action_log(f"估算试剂体积: {volume:.2f}mL", "📊"))
+    else:
+        debug_print(f"📏 使用指定体积: {volume}mL")
+        action_sequence.append(create_action_log(f"使用指定体积: {volume}mL", "📏"))
+    
+    # 4. 验证路径存在
+    debug_print(f"🔍 步骤4: 路径验证...")
+    action_sequence.append(create_action_log("验证转移路径...", "🛤️"))
+    
+    try:
+        path = nx.shortest_path(G, source=reagent_vessel, target=vessel_id)
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"找到转移路径: {' → '.join(path)}", "🛤️"))
+    except nx.NetworkXNoPath:
+        debug_print(f"❌ 无法找到转移路径")
+        action_sequence.append(create_action_log("转移路径不存在", "❌"))
+        raise ValueError(f"从试剂容器 '{reagent_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
+    
+    # 5. 搅拌器设置
+    debug_print(f"🔍 步骤5: 搅拌器设置...")
+    stirrer_id = None
+    if stir:
+        action_sequence.append(create_action_log("准备启动搅拌器", "🌪️"))
+        
+        try:
+            stirrer_id = find_connected_stirrer(G, vessel_id)
+            
+            if stirrer_id:
+                debug_print(f"✅ 找到搅拌器 {stirrer_id}，启动搅拌")
+                action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {stir_speed}rpm)", "🔄"))
+                
+                action_sequence.append({
+                    "device_id": stirrer_id,
+                    "action_name": "start_stir",
+                    "action_kwargs": {
+                        "vessel": {"id": vessel_id},
+                        "stir_speed": stir_speed,
+                        "purpose": f"pH调节: 启动搅拌，准备添加 {reagent}"
+                    }
+                })
+                
+                # 等待搅拌稳定
+                action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": 5}
+                })
+            else:
+                debug_print(f"⚠️ 未找到搅拌器，继续执行")
+                action_sequence.append(create_action_log("未找到搅拌器，跳过搅拌", "⚠️"))
+        
+        except Exception as e:
+            debug_print(f"❌ 搅拌器配置出错: {str(e)}")
+            action_sequence.append(create_action_log(f"搅拌器配置失败: {str(e)}", "❌"))
+    else:
+        debug_print(f"📋 跳过搅拌设置")
+        action_sequence.append(create_action_log("跳过搅拌设置", "⏭️"))
+    
+    # 6. 试剂添加
+    debug_print(f"🔍 步骤6: 试剂添加...")
+    action_sequence.append(create_action_log(f"开始添加试剂 {volume:.2f}mL", "🚰"))
+    
+    # 计算添加时间（pH调节需要缓慢添加）
+    addition_time = max(30.0, volume * 2.0)  # 至少30秒，每mL需要2秒
+    debug_print(f"⏱️ 计算添加时间: {addition_time}s (缓慢注入)")
+    action_sequence.append(create_action_log(f"设置添加时间: {addition_time:.0f}s (缓慢注入)", "⏱️"))
+    
+    try:
+        action_sequence.append(create_action_log("调用泵协议进行试剂转移", "🔄"))
+        
+        pump_actions = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=reagent_vessel,
+            to_vessel=vessel_id,
+            volume=volume,
+            amount="",
+            time=addition_time,
+            viscous=False,
+            rinsing_solvent="",  # pH调节不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=0.5,  # 缓慢注入
+            transfer_flowrate=0.3
+        )
+        
+        action_sequence.extend(pump_actions)
+        debug_print(f"✅ 泵协议生成完成，添加了 {len(pump_actions)} 个动作")
+        action_sequence.append(create_action_log(f"试剂转移完成 ({len(pump_actions)} 个操作)", "✅"))
+        
+        # 🔧 修复体积运算 - 试剂添加成功后更新容器液体体积
+        debug_print(f"🔧 更新容器液体体积...")
+        if "data" in vessel and "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            debug_print(f"📊 添加前容器体积: {current_volume}")
+            
+            # 处理不同的体积数据格式
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    # 增加体积（添加试剂）
+                    vessel["data"]["liquid_volume"][0] += volume
+                    debug_print(f"📊 添加后容器体积: {vessel['data']['liquid_volume'][0]:.2f}mL (+{volume:.2f}mL)")
+                else:
+                    # 如果列表为空，创建新的体积记录
+                    vessel["data"]["liquid_volume"] = [volume]
+                    debug_print(f"📊 初始化容器体积: {volume:.2f}mL")
+            elif isinstance(current_volume, (int, float)):
+                # 直接数值类型
+                vessel["data"]["liquid_volume"] += volume
+                debug_print(f"📊 添加后容器体积: {vessel['data']['liquid_volume']:.2f}mL (+{volume:.2f}mL)")
+            else:
+                debug_print(f"⚠️ 未知的体积数据格式: {type(current_volume)}")
+                # 创建新的体积记录
+                vessel["data"]["liquid_volume"] = volume
+        else:
+            debug_print(f"📊 容器无液体体积数据，创建新记录: {volume:.2f}mL")
+            # 确保vessel有data字段
+            if "data" not in vessel:
+                vessel["data"] = {}
+            vessel["data"]["liquid_volume"] = volume
+            
+        # 🔧 同时更新图中的容器数据
+        if vessel_id in G.nodes():
+            vessel_node_data = G.nodes[vessel_id].get('data', {})
+            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+            
+            if isinstance(current_node_volume, list):
+                if len(current_node_volume) > 0:
+                    G.nodes[vessel_id]['data']['liquid_volume'][0] += volume
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = [volume]
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = current_node_volume + volume
+                
+            debug_print(f"✅ 图节点体积数据已更新")
+        
+        action_sequence.append(create_action_log(f"容器体积已更新 (+{volume:.2f}mL)", "📊"))
+        
+    except Exception as e:
+        debug_print(f"❌ 生成泵协议时出错: {str(e)}")
+        action_sequence.append(create_action_log(f"泵协议生成失败: {str(e)}", "❌"))
+        raise ValueError(f"生成泵协议时出错: {str(e)}")
+    
+    # 7. 混合搅拌
+    if stir and stirrer_id:
+        debug_print(f"🔍 步骤7: 混合搅拌...")
+        action_sequence.append(create_action_log(f"开始混合搅拌 {stir_time:.0f}s", "🌀"))
+        
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "stir",
+            "action_kwargs": {
+                "stir_time": stir_time,
+                "stir_speed": stir_speed,
+                "settling_time": settling_time,
+                "purpose": f"pH调节: 混合试剂，目标pH={ph_value}"
+            }
+        })
+        
+        debug_print(f"✅ 混合搅拌设置完成")
+    else:
+        debug_print(f"⏭️ 跳过混合搅拌")
+        action_sequence.append(create_action_log("跳过混合搅拌", "⏭️"))
+    
+    # 8. 等待平衡
+    debug_print(f"🔍 步骤8: 反应平衡...")
+    action_sequence.append(create_action_log(f"等待pH平衡 {settling_time:.0f}s", "⚖️"))
+    
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": settling_time,
+            "description": f"等待pH平衡到目标值 {ph_value}"
+        }
+    })
+    
+    # 9. 完成总结
+    total_time = addition_time + stir_time + settling_time
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 pH调节协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f}分钟)")
+    debug_print(f"  🧪 试剂: {reagent}")
+    debug_print(f"  📏 体积: {volume:.2f}mL")
+    debug_print(f"  📊 目标pH: {ph_value}")
+    debug_print(f"  🥼 目标容器: {vessel_id}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"pH调节协议完成: {vessel_id} → pH {ph_value} (使用 {volume:.2f}mL {reagent})"
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+
+def generate_adjust_ph_protocol_stepwise(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    ph_value: float,
+    reagent: str,
+    max_volume: float = 10.0,
+    steps: int = 3
+) -> List[Dict[str, Any]]:
+    """
+    分步调节pH的协议（更安全，避免过度调节）
+    
+    Args:
+        G: 网络图
+        vessel: 目标容器字典
+        ph_value: 目标pH值
+        reagent: 酸碱试剂
+        max_volume: 最大试剂体积
+        steps: 分步数量
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id = vessel["id"]
+    
+    debug_print("=" * 60)
+    debug_print(f"🔄 开始分步pH调节")
+    debug_print(f"📋 分步参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  📊 ph_value: {ph_value}")
+    debug_print(f"  🧪 reagent: {reagent}")
+    debug_print(f"  📏 max_volume: {max_volume}mL")
+    debug_print(f"  🔢 steps: {steps}")
+    debug_print("=" * 60)
+    
+    action_sequence = []
+    
+    # 每步添加的体积
+    step_volume = max_volume / steps
+    debug_print(f"📊 每步体积: {step_volume:.2f}mL")
+    
+    action_sequence.append(create_action_log(f"开始分步pH调节 ({steps}步)", "🔄"))
+    action_sequence.append(create_action_log(f"每步添加: {step_volume:.2f}mL", "📏"))
+    
+    for i in range(steps):
+        debug_print(f"🔄 执行第 {i+1}/{steps} 步，添加 {step_volume:.2f}mL")
+        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步开始", "🚀"))
+        
+        # 生成单步协议
+        step_actions = generate_adjust_ph_protocol(
+            G=G,
+            vessel=vessel,  # 🔧 直接传递vessel字典
+            ph_value=ph_value,
+            reagent=reagent,
+            volume=step_volume,
+            stir=True,
+            stir_speed=300.0,
+            stir_time=30.0,
+            settling_time=20.0
+        )
+        
+        action_sequence.extend(step_actions)
+        debug_print(f"✅ 第 {i+1}/{steps} 步完成，添加了 {len(step_actions)} 个动作")
+        action_sequence.append(create_action_log(f"第 {i+1}/{steps} 步完成", "✅"))
+        
+        # 步骤间等待
+        if i < steps - 1:
+            debug_print(f"⏳ 步骤间等待30s")
+            action_sequence.append(create_action_log("步骤间等待...", "⏳"))
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {
+                    "time": 30,
+                    "description": f"pH调节第{i+1}步完成，等待下一步"
+                }
+            })
+    
+    debug_print(f"🎉 分步pH调节完成，共 {len(action_sequence)} 个动作")
+    action_sequence.append(create_action_log("分步pH调节全部完成", "🎉"))
+    
+    return action_sequence
+
+# 便捷函数：常用pH调节
+def generate_acidify_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    target_ph: float = 2.0,
+    acid: str = "hydrochloric acid"
+) -> List[Dict[str, Any]]:
+    """酸化协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🍋 生成酸化协议: {vessel_id} → pH {target_ph} (使用 {acid})")
+    return generate_adjust_ph_protocol(
+        G, vessel, target_ph, acid
+    )
+
+def generate_basify_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    target_ph: float = 12.0,
+    base: str = "sodium hydroxide"
+) -> List[Dict[str, Any]]:
+    """碱化协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🧂 生成碱化协议: {vessel_id} → pH {target_ph} (使用 {base})")
+    return generate_adjust_ph_protocol(
+        G, vessel, target_ph, base
+    )
+
+def generate_neutralize_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    reagent: str = "sodium hydroxide"
+) -> List[Dict[str, Any]]:
+    """中和协议（pH=7）"""
+    vessel_id = vessel["id"]
+    debug_print(f"⚖️ 生成中和协议: {vessel_id} → pH 7.0 (使用 {reagent})")
+    return generate_adjust_ph_protocol(
+        G, vessel, 7.0, reagent
+    )
+
+# 测试函数
+def test_adjust_ph_protocol():
+    """测试pH调节协议"""
+    debug_print("=== ADJUST PH PROTOCOL 增强版测试 ===")
+    
+    # 测试体积计算
+    debug_print("🧮 测试体积计算...")
+    test_cases = [
+        (2.0, "hydrochloric acid", 100.0),
+        (4.0, "hydrochloric acid", 100.0),
+        (12.0, "sodium hydroxide", 100.0),
+        (10.0, "sodium hydroxide", 100.0),
+        (7.0, "unknown reagent", 100.0)
+    ]
+    
+    for ph, reagent, volume in test_cases:
+        result = calculate_reagent_volume(ph, reagent, volume)
+        debug_print(f"📊 {reagent} → pH {ph}: {result:.2f}mL")
+    
+    debug_print("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_adjust_ph_protocol()

unilabos/compile/centrifuge_protocol.py

@@ -1,5 +1,59 @@
 from typing import List, Dict, Any
 import networkx as nx
+from .pump_protocol import generate_pump_protocol
+
+
+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """
+    获取容器中的液体体积
+    """
+    if vessel not in G.nodes():
+        return 0.0
+    
+    vessel_data = G.nodes[vessel].get('data', {})
+    liquids = vessel_data.get('liquid', [])
+    
+    total_volume = 0.0
+    for liquid in liquids:
+        if isinstance(liquid, dict) and 'liquid_volume' in liquid:
+            total_volume += liquid['liquid_volume']
+    
+    return total_volume
+
+
+def find_centrifuge_device(G: nx.DiGraph) -> str:
+    """
+    查找离心机设备
+    """
+    centrifuge_nodes = [node for node in G.nodes() 
+                       if (G.nodes[node].get('class') or '') == 'virtual_centrifuge']
+    
+    if centrifuge_nodes:
+        return centrifuge_nodes[0]
+    
+    raise ValueError("系统中未找到离心机设备")
+
+
+def find_centrifuge_vessel(G: nx.DiGraph) -> str:
+    """
+    查找离心机专用容器
+    """
+    possible_names = [
+        "centrifuge_tube",
+        "centrifuge_vessel", 
+        "tube_centrifuge",
+        "vessel_centrifuge",
+        "centrifuge",
+        "tube_15ml",
+        "tube_50ml"
+    ]
+    
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            return vessel_name
+    
+    raise ValueError(f"未找到离心机容器。尝试了以下名称: {possible_names}")
+
 
 def generate_centrifuge_protocol(
     G: nx.DiGraph,
@@ -9,115 +63,223 @@ def generate_centrifuge_protocol(
     temp: float = 25.0
 ) -> List[Dict[str, Any]]:
     """
-    生成离心操作的协议序列
+    生成离心操作的协议序列，复用 pump_protocol 的成熟算法
+    
+    离心流程：
+    1. 液体转移：将待离心溶液从源容器转移到离心机容器
+    2. 离心操作：执行离心分离
+    3. 上清液转移：将离心后的上清液转移回原容器或新容器
+    4. 沉淀处理：处理离心沉淀（可选）
     
     Args:
-        G: 有向图，节点为设备和容器
-        vessel: 离心容器名称
+        G: 有向图，节点为设备和容器，边为流体管道
+        vessel: 包含待离心溶液的容器名称
         speed: 离心速度 (rpm)
         time: 离心时间 (秒)
-        temp: 温度 (摄氏度，可选)
+        temp: 离心温度 (°C)，默认25°C
     
     Returns:
         List[Dict[str, Any]]: 离心操作的动作序列
     
     Raises:
-        ValueError: 当找不到离心机设备时抛出异常
+        ValueError: 当找不到必要的设备时抛出异常
     
     Examples:
-        centrifuge_protocol = generate_centrifuge_protocol(G, "reactor", 5000, 300, 4.0)
+        centrifuge_actions = generate_centrifuge_protocol(G, "reaction_mixture", 5000, 600, 4.0)
     """
     action_sequence = []
     
-    # 查找离心机设备
-    centrifuge_nodes = [node for node in G.nodes() 
-                       if G.nodes[node].get('class') == 'virtual_centrifuge']
+    print(f"CENTRIFUGE: 开始生成离心协议")
+    print(f"  - 源容器: {vessel}")
+    print(f"  - 离心速度: {speed} rpm")
+    print(f"  - 离心时间: {time}s ({time/60:.1f}分钟)")
+    print(f"  - 离心温度: {temp}°C")
     
-    if not centrifuge_nodes:
-        raise ValueError("没有找到可用的离心机设备")
-    
-    # 使用第一个可用的离心机
-    centrifuge_id = centrifuge_nodes[0]
-    
-    # 验证容器是否存在
+    # 验证源容器存在
     if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
+        raise ValueError(f"源容器 '{vessel}' 不存在于系统中")
     
-    # 执行离心操作
-    action_sequence.append({
+    # 获取源容器中的液体体积
+    source_volume = get_vessel_liquid_volume(G, vessel)
+    print(f"CENTRIFUGE: 源容器 {vessel} 中有 {source_volume} mL 液体")
+    
+    # 查找离心机设备
+    try:
+        centrifuge_id = find_centrifuge_device(G)
+        print(f"CENTRIFUGE: 找到离心机: {centrifuge_id}")
+    except ValueError as e:
+        raise ValueError(f"无法找到离心机: {str(e)}")
+    
+    # 查找离心机容器
+    try:
+        centrifuge_vessel = find_centrifuge_vessel(G)
+        print(f"CENTRIFUGE: 找到离心机容器: {centrifuge_vessel}")
+    except ValueError as e:
+        raise ValueError(f"无法找到离心机容器: {str(e)}")
+    
+    # === 简化的体积计算策略 ===
+    if source_volume > 0:
+        # 如果能检测到液体体积，使用实际体积的大部分
+        transfer_volume = min(source_volume * 0.9, 15.0)  # 90%或最多15mL（离心管通常较小）
+        print(f"CENTRIFUGE: 检测到液体体积，将转移 {transfer_volume} mL")
+    else:
+        # 如果检测不到液体体积，默认转移标准量
+        transfer_volume = 10.0  # 标准离心管体积
+        print(f"CENTRIFUGE: 未检测到液体体积，默认转移 {transfer_volume} mL")
+    
+    # === 第一步：将待离心溶液转移到离心机容器 ===
+    print(f"CENTRIFUGE: 将 {transfer_volume} mL 溶液从 {vessel} 转移到 {centrifuge_vessel}")
+    try:
+        # 使用成熟的 pump_protocol 算法进行液体转移
+        transfer_to_centrifuge_actions = generate_pump_protocol(
+            G=G,
+            from_vessel=vessel,
+            to_vessel=centrifuge_vessel,
+            volume=transfer_volume,
+            flowrate=1.0,  # 离心转移用慢速，避免气泡
+            transfer_flowrate=1.0
+        )
+        action_sequence.extend(transfer_to_centrifuge_actions)
+    except Exception as e:
+        raise ValueError(f"无法将溶液转移到离心机: {str(e)}")
+    
+    # 转移后等待
+    wait_action = {
+        "action_name": "wait",
+        "action_kwargs": {"time": 5}
+    }
+    action_sequence.append(wait_action)
+    
+    # === 第二步：执行离心操作 ===
+    print(f"CENTRIFUGE: 执行离心操作")
+    centrifuge_action = {
         "device_id": centrifuge_id,
         "action_name": "centrifuge",
         "action_kwargs": {
-            "vessel": vessel,
+            "vessel": {"id": centrifuge_vessel},
             "speed": speed,
             "time": time,
             "temp": temp
         }
-    })
+    }
+    action_sequence.append(centrifuge_action)
+    
+    # 离心后等待系统稳定
+    wait_action = {
+        "action_name": "wait",
+        "action_kwargs": {"time": 10}  # 离心后等待稍长，让沉淀稳定
+    }
+    action_sequence.append(wait_action)
+    
+    # === 第三步：将上清液转移回原容器 ===
+    print(f"CENTRIFUGE: 将上清液从离心机转移回 {vessel}")
+    try:
+        # 估算上清液体积（约为转移体积的80% - 假设20%成为沉淀）
+        supernatant_volume = transfer_volume * 0.8
+        print(f"CENTRIFUGE: 预计上清液体积 {supernatant_volume} mL")
+        
+        transfer_back_actions = generate_pump_protocol(
+            G=G,
+            from_vessel=centrifuge_vessel,
+            to_vessel=vessel,
+            volume=supernatant_volume,
+            flowrate=0.5,  # 上清液转移更慢，避免扰动沉淀
+            transfer_flowrate=0.5
+        )
+        action_sequence.extend(transfer_back_actions)
+    except Exception as e:
+        print(f"CENTRIFUGE: 将上清液转移回容器失败: {str(e)}")
+    
+    # === 第四步：清洗离心机容器 ===
+    print(f"CENTRIFUGE: 清洗离心机容器")
+    try:
+        # 查找清洗溶剂
+        cleaning_solvent = None
+        for solvent in ["flask_water", "flask_ethanol", "flask_acetone"]:
+            if solvent in G.nodes():
+                cleaning_solvent = solvent
+                break
+        
+        if cleaning_solvent:
+            # 用少量溶剂清洗离心管
+            cleaning_volume = 5.0  # 5mL清洗
+            print(f"CENTRIFUGE: 用 {cleaning_volume} mL {cleaning_solvent} 清洗")
+            
+            # 清洗溶剂加入
+            cleaning_actions = generate_pump_protocol(
+                G=G,
+                from_vessel=cleaning_solvent,
+                to_vessel=centrifuge_vessel,
+                volume=cleaning_volume,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            action_sequence.extend(cleaning_actions)
+            
+            # 将清洗液转移到废液
+            if "waste_workup" in G.nodes():
+                waste_actions = generate_pump_protocol(
+                    G=G,
+                    from_vessel=centrifuge_vessel,
+                    to_vessel="waste_workup",
+                    volume=cleaning_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=2.0
+                )
+                action_sequence.extend(waste_actions)
+        
+    except Exception as e:
+        print(f"CENTRIFUGE: 清洗步骤失败: {str(e)}")
+    
+    print(f"CENTRIFUGE: 生成了 {len(action_sequence)} 个动作")
+    print(f"CENTRIFUGE: 离心协议生成完成")
+    print(f"CENTRIFUGE: 总处理体积: {transfer_volume} mL")
     
     return action_sequence
 
 
-def generate_multi_step_centrifuge_protocol(
+# 便捷函数：常用离心方案
+def generate_low_speed_centrifuge_protocol(
     G: nx.DiGraph,
     vessel: str,
-    steps: List[Dict[str, Any]]
+    time: float = 300.0  # 5分钟
 ) -> List[Dict[str, Any]]:
-    """
-    生成多步骤离心操作的协议序列
+    """低速离心：细胞分离或大颗粒沉淀"""
+    return generate_centrifuge_protocol(G, vessel, 1000.0, time, 4.0)
 
-    Args:
-        G: 有向图，节点为设备和容器
-        vessel: 离心容器名称
-        steps: 离心步骤列表，每个步骤包含 speed, time, temp 参数
 
-    Returns:
-        List[Dict[str, Any]]: 多步骤离心操作的动作序列
+def generate_high_speed_centrifuge_protocol(
+    G: nx.DiGraph,
+    vessel: str,
+    time: float = 600.0  # 10分钟
+) -> List[Dict[str, Any]]:
+    """高速离心：蛋白质沉淀或小颗粒分离"""
+    return generate_centrifuge_protocol(G, vessel, 12000.0, time, 4.0)
 
-    Examples:
-        steps = [
-            {"speed": 1000, "time": 60, "temp": 4.0},   # 低速预离心
-            {"speed": 12000, "time": 600, "temp": 4.0}  # 高速离心
-        ]
-        protocol = generate_multi_step_centrifuge_protocol(G, "reactor", steps)
-    """
-    action_sequence = []
 
-    # 查找离心机设备
-    centrifuge_nodes = [node for node in G.nodes() 
-                       if G.nodes[node].get('class') == 'virtual_centrifuge']
+def generate_standard_centrifuge_protocol(
+    G: nx.DiGraph,
+    vessel: str,
+    time: float = 600.0  # 10分钟
+) -> List[Dict[str, Any]]:
+    """标准离心：常规样品处理"""
+    return generate_centrifuge_protocol(G, vessel, 5000.0, time, 25.0)
 
-    if not centrifuge_nodes:
-        raise ValueError("没有找到可用的离心机设备")
 
-    centrifuge_id = centrifuge_nodes[0]
+def generate_cold_centrifuge_protocol(
+    G: nx.DiGraph,
+    vessel: str,
+    speed: float = 5000.0,
+    time: float = 600.0
+) -> List[Dict[str, Any]]:
+    """冷冻离心：热敏感样品处理"""
+    return generate_centrifuge_protocol(G, vessel, speed, time, 4.0)
 
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
 
-    # 执行每个离心步骤
-    for i, step in enumerate(steps):
-        speed = step.get('speed', 5000)
-        time = step.get('time', 300)
-        temp = step.get('temp', 25.0)
-        
-        action_sequence.append({
-            "device_id": centrifuge_id,
-            "action_name": "centrifuge",
-            "action_kwargs": {
-                "vessel": vessel,
-                "speed": speed,
-                "time": time,
-                "temp": temp
-            }
-        })
-        
-        # 步骤间等待时间（除了最后一步）
-        if i < len(steps) - 1:
-            action_sequence.append({
-                "action_name": "wait", 
-                "action_kwargs": {"time": 3}
-            })
-    
-    return action_sequence
+def generate_ultra_centrifuge_protocol(
+    G: nx.DiGraph,
+    vessel: str,
+    time: float = 1800.0  # 30分钟
+) -> List[Dict[str, Any]]:
+    """超高速离心：超细颗粒分离"""
+    return generate_centrifuge_protocol(G, vessel, 15000.0, time, 4.0)

unilabos/compile/clean_vessel_protocol.py

@@ -1,22 +1,81 @@
 from typing import List, Dict, Any
 import networkx as nx
+from .utils.vessel_parser import get_vessel, find_solvent_vessel
+from .pump_protocol import generate_pump_protocol
+
+
+def find_solvent_vessel_by_any_match(G: nx.DiGraph, solvent: str) -> str:
+    """
+    增强版溶剂容器查找，支持各种匹配方式的别名函数
+    """
+    return find_solvent_vessel(G, solvent)
+
+
+def find_waste_vessel(G: nx.DiGraph) -> str:
+    """
+    查找废液容器
+    """
+    possible_waste_names = [
+        "waste_workup",
+        "flask_waste", 
+        "bottle_waste",
+        "waste",
+        "waste_vessel",
+        "waste_container"
+    ]
+    
+    for waste_name in possible_waste_names:
+        if waste_name in G.nodes():
+            return waste_name
+    
+    raise ValueError(f"未找到废液容器。尝试了以下名称: {possible_waste_names}")
+
+
+def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
+    """
+    查找与指定容器相连的加热冷却设备
+    """
+    # 查找所有加热冷却设备节点
+    heatchill_nodes = [node for node in G.nodes() 
+                      if (G.nodes[node].get('class') or '') == 'virtual_heatchill']
+    
+    # 检查哪个加热设备与目标容器相连（机械连接）
+    for heatchill in heatchill_nodes:
+        if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+            return heatchill
+    
+    # 如果没有直接连接，返回第一个可用的加热设备
+    if heatchill_nodes:
+        return heatchill_nodes[0]
+    
+    return None  # 没有加热设备也可以工作，只是不能加热
+
 
 def generate_clean_vessel_protocol(
     G: nx.DiGraph,
-    vessel: str,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     solvent: str,
     volume: float,
     temp: float,
     repeats: int = 1
 ) -> List[Dict[str, Any]]:
     """
-    生成容器清洗操作的协议序列，使用transfer操作实现清洗
+    生成容器清洗操作的协议序列，复用 pump_protocol 的成熟算法
+    
+    清洗流程：
+    1. 查找溶剂容器和废液容器
+    2. 如果需要加热，启动加热设备
+    3. 重复以下操作 repeats 次：
+       a. 使用 pump_protocol 将溶剂从溶剂容器转移到目标容器
+       b. (可选) 等待清洗作用时间
+       c. 使用 pump_protocol 将清洗液从目标容器转移到废液容器
+    4. 如果加热了，停止加热
     
     Args:
-        G: 有向图，节点为设备和容器
-        vessel: 要清洗的容器名称
-        solvent: 用于清洗容器的溶剂名称
-        volume: 清洗溶剂的体积
+        G: 有向图，节点为设备和容器，边为流体管道
+        vessel: 要清洗的容器字典（包含id字段）
+        solvent: 用于清洗的溶剂名称  
+        volume: 每次清洗使用的溶剂体积
         temp: 清洗时的温度
         repeats: 清洗操作的重复次数，默认为 1
     
@@ -24,103 +83,367 @@ def generate_clean_vessel_protocol(
         List[Dict[str, Any]]: 容器清洗操作的动作序列
     
     Raises:
-        ValueError: 当找不到必要的设备时抛出异常
+        ValueError: 当找不到必要的容器或设备时抛出异常
     
     Examples:
-        clean_vessel_protocol = generate_clean_vessel_protocol(G, "reactor", "water", 50.0, 25.0, 2)
+        clean_protocol = generate_clean_vessel_protocol(G, {"id": "main_reactor"}, "water", 100.0, 60.0, 2)
     """
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
     action_sequence = []
     
-    # 查找虚拟转移泵设备进行清洗操作
-    pump_nodes = [node for node in G.nodes() 
-                  if G.nodes[node].get('class') == 'virtual_transfer_pump']
+    print(f"CLEAN_VESSEL: 开始生成容器清洗协议")
+    print(f"  - 目标容器: {vessel} (ID: {vessel_id})")
+    print(f"  - 清洗溶剂: {solvent}")
+    print(f"  - 清洗体积: {volume} mL")
+    print(f"  - 清洗温度: {temp}°C")
+    print(f"  - 重复次数: {repeats}")
     
-    if not pump_nodes:
-        raise ValueError("没有找到可用的转移泵设备进行容器清洗")
-    
-    pump_id = pump_nodes[0]
-    
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
+    # 验证目标容器存在
+    if vessel_id not in G.nodes():
+        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
     
     # 查找溶剂容器
-    solvent_vessel = f"flask_{solvent}"
-    if solvent_vessel not in G.nodes():
-        raise ValueError(f"溶剂容器 {solvent_vessel} 不存在于图中")
+    try:
+        solvent_vessel = find_solvent_vessel(G, solvent)
+        print(f"CLEAN_VESSEL: 找到溶剂容器: {solvent_vessel}")
+    except ValueError as e:
+        raise ValueError(f"无法找到溶剂容器: {str(e)}")
     
     # 查找废液容器
-    waste_vessel = "flask_waste"
-    if waste_vessel not in G.nodes():
-        raise ValueError(f"废液容器 {waste_vessel} 不存在于图中")
+    try:
+        waste_vessel = find_waste_vessel(G)
+        print(f"CLEAN_VESSEL: 找到废液容器: {waste_vessel}")
+    except ValueError as e:
+        raise ValueError(f"无法找到废液容器: {str(e)}")
     
-    # 查找加热设备（如果需要加热）
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
+    # 查找加热设备（可选）
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
+    if heatchill_id:
+        print(f"CLEAN_VESSEL: 找到加热设备: {heatchill_id}")
+    else:
+        print(f"CLEAN_VESSEL: 未找到加热设备，将在室温下清洗")
     
-    heatchill_id = heatchill_nodes[0] if heatchill_nodes else None
+    # 🔧 新增：记录清洗前的容器状态
+    print(f"CLEAN_VESSEL: 记录清洗前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    print(f"CLEAN_VESSEL: 清洗前液体体积: {original_liquid_volume:.2f}mL")
     
-    # 执行清洗操作序列
+    # 第一步：如果需要加热且有加热设备，启动加热
+    if temp > 25.0 and heatchill_id:
+        print(f"CLEAN_VESSEL: 启动加热至 {temp}°C")
+        heatchill_start_action = {
+            "device_id": heatchill_id,
+            "action_name": "heat_chill_start",
+            "action_kwargs": {
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "temp": temp,
+                "purpose": f"cleaning with {solvent}"
+            }
+        }
+        action_sequence.append(heatchill_start_action)
+        
+        # 等待温度稳定
+        wait_action = {
+            "action_name": "wait", 
+            "action_kwargs": {"time": 30}  # 等待30秒让温度稳定
+        }
+        action_sequence.append(wait_action)
+    
+    # 第二步：重复清洗操作
     for repeat in range(repeats):
-        # 1. 如果需要加热，先设置温度
-        if temp > 25.0 and heatchill_id:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_start",
-                "action_kwargs": {
-                    "vessel": vessel,
-                    "temp": temp,
-                    "purpose": "cleaning"
-                }
-            })
+        print(f"CLEAN_VESSEL: 执行第 {repeat + 1} 次清洗")
         
-        # 2. 使用transfer操作：从溶剂容器转移清洗溶剂到目标容器
-        action_sequence.append({
-            "device_id": pump_id,
-            "action_name": "transfer",
-            "action_kwargs": {
-                "from_vessel": solvent_vessel,
-                "to_vessel": vessel,
-                "volume": volume,
-                "amount": f"cleaning with {solvent} - cycle {repeat + 1}",
-                "time": 0.0,
-                "viscous": False,
-                "rinsing_solvent": "",
-                "rinsing_volume": 0.0,
-                "rinsing_repeats": 0,
-                "solid": False
+        # 2a. 使用 pump_protocol 将溶剂转移到目标容器
+        print(f"CLEAN_VESSEL: 将 {volume} mL {solvent} 转移到 {vessel_id}")
+        try:
+            # 调用成熟的 pump_protocol 算法
+            add_solvent_actions = generate_pump_protocol(
+                G=G,
+                from_vessel=solvent_vessel,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
+                volume=volume,
+                flowrate=2.5,  # 适中的流速，避免飞溅
+                transfer_flowrate=2.5
+            )
+            action_sequence.extend(add_solvent_actions)
+            
+            # 🔧 新增：更新容器体积（添加清洗溶剂）
+            print(f"CLEAN_VESSEL: 更新容器体积 - 添加清洗溶剂 {volume:.2f}mL")
+            if "data" not in vessel:
+                vessel["data"] = {}
+            
+            if "liquid_volume" in vessel["data"]:
+                current_volume = vessel["data"]["liquid_volume"]
+                if isinstance(current_volume, list):
+                    if len(current_volume) > 0:
+                        vessel["data"]["liquid_volume"][0] += volume
+                        print(f"CLEAN_VESSEL: 添加溶剂后体积: {vessel['data']['liquid_volume'][0]:.2f}mL (+{volume:.2f}mL)")
+                    else:
+                        vessel["data"]["liquid_volume"] = [volume]
+                        print(f"CLEAN_VESSEL: 初始化清洗体积: {volume:.2f}mL")
+                elif isinstance(current_volume, (int, float)):
+                    vessel["data"]["liquid_volume"] += volume
+                    print(f"CLEAN_VESSEL: 添加溶剂后体积: {vessel['data']['liquid_volume']:.2f}mL (+{volume:.2f}mL)")
+                else:
+                    vessel["data"]["liquid_volume"] = volume
+                    print(f"CLEAN_VESSEL: 重置体积为: {volume:.2f}mL")
+            else:
+                vessel["data"]["liquid_volume"] = volume
+                print(f"CLEAN_VESSEL: 创建新体积记录: {volume:.2f}mL")
+            
+            # 🔧 同时更新图中的容器数据
+            if vessel_id in G.nodes():
+                if 'data' not in G.nodes[vessel_id]:
+                    G.nodes[vessel_id]['data'] = {}
+                
+                vessel_node_data = G.nodes[vessel_id]['data']
+                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+                
+                if isinstance(current_node_volume, list):
+                    if len(current_node_volume) > 0:
+                        G.nodes[vessel_id]['data']['liquid_volume'][0] += volume
+                    else:
+                        G.nodes[vessel_id]['data']['liquid_volume'] = [volume]
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = current_node_volume + volume
+                
+                print(f"CLEAN_VESSEL: 图节点体积数据已更新")
+            
+        except Exception as e:
+            raise ValueError(f"无法将溶剂转移到容器: {str(e)}")
+        
+        # 2b. 等待清洗作用时间（让溶剂充分清洗容器）
+        cleaning_wait_time = 60 if temp > 50.0 else 30  # 高温下等待更久
+        print(f"CLEAN_VESSEL: 等待清洗作用 {cleaning_wait_time} 秒")
+        wait_action = {
+            "action_name": "wait", 
+            "action_kwargs": {"time": cleaning_wait_time}
+        }
+        action_sequence.append(wait_action)
+        
+        # 2c. 使用 pump_protocol 将清洗液转移到废液容器
+        print(f"CLEAN_VESSEL: 将清洗液从 {vessel_id} 转移到废液容器")
+        try:
+            # 调用成熟的 pump_protocol 算法
+            remove_waste_actions = generate_pump_protocol(
+                G=G,
+                from_vessel=vessel_id,  # 🔧 使用 vessel_id
+                to_vessel=waste_vessel,
+                volume=volume,
+                flowrate=2.5,  # 适中的流速
+                transfer_flowrate=2.5
+            )
+            action_sequence.extend(remove_waste_actions)
+            
+            # 🔧 新增：更新容器体积（移除清洗液）
+            print(f"CLEAN_VESSEL: 更新容器体积 - 移除清洗液 {volume:.2f}mL")
+            if "data" in vessel and "liquid_volume" in vessel["data"]:
+                current_volume = vessel["data"]["liquid_volume"]
+                if isinstance(current_volume, list):
+                    if len(current_volume) > 0:
+                        vessel["data"]["liquid_volume"][0] = max(0.0, vessel["data"]["liquid_volume"][0] - volume)
+                        print(f"CLEAN_VESSEL: 移除清洗液后体积: {vessel['data']['liquid_volume'][0]:.2f}mL (-{volume:.2f}mL)")
+                    else:
+                        vessel["data"]["liquid_volume"] = [0.0]
+                        print(f"CLEAN_VESSEL: 重置体积为0mL")
+                elif isinstance(current_volume, (int, float)):
+                    vessel["data"]["liquid_volume"] = max(0.0, current_volume - volume)
+                    print(f"CLEAN_VESSEL: 移除清洗液后体积: {vessel['data']['liquid_volume']:.2f}mL (-{volume:.2f}mL)")
+                else:
+                    vessel["data"]["liquid_volume"] = 0.0
+                    print(f"CLEAN_VESSEL: 重置体积为0mL")
+            
+            # 🔧 同时更新图中的容器数据
+            if vessel_id in G.nodes():
+                vessel_node_data = G.nodes[vessel_id].get('data', {})
+                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+                
+                if isinstance(current_node_volume, list):
+                    if len(current_node_volume) > 0:
+                        G.nodes[vessel_id]['data']['liquid_volume'][0] = max(0.0, current_node_volume[0] - volume)
+                    else:
+                        G.nodes[vessel_id]['data']['liquid_volume'] = [0.0]
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = max(0.0, current_node_volume - volume)
+                
+                print(f"CLEAN_VESSEL: 图节点体积数据已更新")
+            
+        except Exception as e:
+            raise ValueError(f"无法将清洗液转移到废液容器: {str(e)}")
+        
+        # 2d. 清洗循环间的短暂等待
+        if repeat < repeats - 1:  # 不是最后一次清洗
+            print(f"CLEAN_VESSEL: 清洗循环间等待")
+            wait_action = {
+                "action_name": "wait", 
+                "action_kwargs": {"time": 10}
             }
-        })
+            action_sequence.append(wait_action)
     
-        # 3. 等待清洗作用时间（可选，可以添加wait操作）
-        # 这里省略wait操作，直接进行下一步
-        
-        # 4. 将清洗后的溶剂转移到废液容器
-        action_sequence.append({
-            "device_id": pump_id,
-            "action_name": "transfer",
+    # 第三步：如果加热了，停止加热
+    if temp > 25.0 and heatchill_id:
+        print(f"CLEAN_VESSEL: 停止加热")
+        heatchill_stop_action = {
+            "device_id": heatchill_id,
+            "action_name": "heat_chill_stop",
             "action_kwargs": {
-                "from_vessel": vessel,
-                "to_vessel": waste_vessel,
-                "volume": volume,
-                "amount": f"waste from cleaning {vessel} - cycle {repeat + 1}",
-                "time": 0.0,
-                "viscous": False,
-                "rinsing_solvent": "",
-                "rinsing_volume": 0.0,
-                "rinsing_repeats": 0,
-                "solid": False
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
             }
-        })
+        }
+        action_sequence.append(heatchill_stop_action)
     
-        # 5. 如果加热了，停止加热
-        if temp > 25.0 and heatchill_id:
-            action_sequence.append({
-                "device_id": heatchill_id,
-                "action_name": "heat_chill_stop",
-                "action_kwargs": {
-                    "vessel": vessel
-                }
-            })
+    # 🔧 新增：清洗完成后的状态报告
+    final_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    print(f"CLEAN_VESSEL: 清洗完成")
+    print(f"  - 清洗前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 清洗后体积: {final_liquid_volume:.2f}mL")
+    print(f"  - 生成了 {len(action_sequence)} 个动作")
     
     return action_sequence
+
+
+# 便捷函数：常用清洗方案
+def generate_quick_clean_protocol(
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    solvent: str = "water", 
+    volume: float = 100.0
+) -> List[Dict[str, Any]]:
+    """快速清洗：室温，单次清洗"""
+    return generate_clean_vessel_protocol(G, vessel, solvent, volume, 25.0, 1)
+
+
+def generate_thorough_clean_protocol(
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    solvent: str = "water", 
+    volume: float = 150.0,
+    temp: float = 60.0
+) -> List[Dict[str, Any]]:
+    """深度清洗：加热，多次清洗"""
+    return generate_clean_vessel_protocol(G, vessel, solvent, volume, temp, 3)
+
+
+def generate_organic_clean_protocol(
+    G: nx.DiGraph, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    volume: float = 100.0
+) -> List[Dict[str, Any]]:
+    """有机清洗：先用有机溶剂，再用水清洗"""
+    action_sequence = []
+    
+    # 第一步：有机溶剂清洗
+    try:
+        organic_actions = generate_clean_vessel_protocol(
+            G, vessel, "acetone", volume, 25.0, 2
+        )
+        action_sequence.extend(organic_actions)
+    except ValueError:
+        # 如果没有丙酮，尝试乙醇
+        try:
+            organic_actions = generate_clean_vessel_protocol(
+                G, vessel, "ethanol", volume, 25.0, 2
+            )
+            action_sequence.extend(organic_actions)
+        except ValueError:
+            print("警告：未找到有机溶剂，跳过有机清洗步骤")
+    
+    # 第二步：水清洗
+    water_actions = generate_clean_vessel_protocol(
+        G, vessel, "water", volume, 25.0, 2
+    )
+    action_sequence.extend(water_actions)
+    
+    return action_sequence
+
+
+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """获取容器中的液体体积（修复版）"""
+    if vessel not in G.nodes():
+        return 0.0
+    
+    vessel_data = G.nodes[vessel].get('data', {})
+    liquids = vessel_data.get('liquid', [])
+    
+    total_volume = 0.0
+    for liquid in liquids:
+        if isinstance(liquid, dict):
+            # 支持两种格式：新格式 (name, volume) 和旧格式 (liquid_type, liquid_volume)
+            volume = liquid.get('volume') or liquid.get('liquid_volume', 0.0)
+            total_volume += volume
+    
+    return total_volume
+
+
+def get_vessel_liquid_types(G: nx.DiGraph, vessel: str) -> List[str]:
+    """获取容器中所有液体的类型"""
+    if vessel not in G.nodes():
+        return []
+    
+    vessel_data = G.nodes[vessel].get('data', {})
+    liquids = vessel_data.get('liquid', [])
+    
+    liquid_types = []
+    for liquid in liquids:
+        if isinstance(liquid, dict):
+            # 支持两种格式的液体类型字段
+            liquid_type = liquid.get('liquid_type') or liquid.get('name', '')
+            if liquid_type:
+                liquid_types.append(liquid_type)
+    
+    return liquid_types
+
+
+def find_vessel_by_content(G: nx.DiGraph, content: str) -> List[str]:
+    """
+    根据内容物查找所有匹配的容器
+    返回匹配容器的ID列表
+    """
+    matching_vessels = []
+    
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            # 检查容器名称匹配
+            node_name = G.nodes[node_id].get('name', '').lower()
+            if content.lower() in node_id.lower() or content.lower() in node_name:
+                matching_vessels.append(node_id)
+                continue
+            
+            # 检查液体类型匹配
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            config_data = G.nodes[node_id].get('config', {})
+            
+            # 检查 reagent_name 和 config.reagent
+            reagent_name = vessel_data.get('reagent_name', '').lower()
+            config_reagent = config_data.get('reagent', '').lower()
+            
+            if (content.lower() == reagent_name or 
+                content.lower() == config_reagent):
+                matching_vessels.append(node_id)
+                continue
+            
+            # 检查液体列表
+            for liquid in liquids:
+                if isinstance(liquid, dict):
+                    liquid_type = liquid.get('liquid_type') or liquid.get('name', '')
+                    if liquid_type.lower() == content.lower():
+                        matching_vessels.append(node_id)
+                        break
+    
+    return matching_vessels

unilabos/compile/dry_protocol.py

@@ -0,0 +1,335 @@
+import networkx as nx
+from typing import List, Dict, Any
+
+from unilabos.compile.utils.vessel_parser import get_vessel
+
+
+def find_connected_heater(G: nx.DiGraph, vessel: str) -> str:
+    """
+    查找与容器相连的加热器
+    
+    Args:
+        G: 网络图
+        vessel: 容器名称
+    
+    Returns:
+        str: 加热器ID，如果没有则返回None
+    """
+    print(f"DRY: 正在查找与容器 '{vessel}' 相连的加热器...")
+    
+    # 查找所有加热器节点
+    heater_nodes = [node for node in G.nodes() 
+                   if ('heater' in node.lower() or 
+                       'heat' in node.lower() or
+                       G.nodes[node].get('class') == 'virtual_heatchill' or
+                       G.nodes[node].get('type') == 'heater')]
+    
+    print(f"DRY: 找到的加热器节点: {heater_nodes}")
+    
+    # 检查是否有加热器与目标容器相连
+    for heater in heater_nodes:
+        if G.has_edge(heater, vessel) or G.has_edge(vessel, heater):
+            print(f"DRY: 找到与容器 '{vessel}' 相连的加热器: {heater}")
+            return heater
+    
+    # 如果没有直接连接，查找距离最近的加热器
+    for heater in heater_nodes:
+        try:
+            path = nx.shortest_path(G, source=heater, target=vessel)
+            if len(path) <= 3:  # 最多2个中间节点
+                print(f"DRY: 找到距离较近的加热器: {heater}, 路径: {' → '.join(path)}")
+                return heater
+        except nx.NetworkXNoPath:
+            continue
+    
+    print(f"DRY: 未找到与容器 '{vessel}' 相连的加热器")
+    return None
+
+
+def generate_dry_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    compound: str = "",  # 🔧 修改：参数顺序调整，并设置默认值
+    **kwargs  # 接收其他可能的参数但不使用
+) -> List[Dict[str, Any]]:
+    """
+    生成干燥协议序列
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（从XDL传入）
+        compound: 化合物名称（从XDL传入，可选）
+        **kwargs: 其他可选参数，但不使用
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    action_sequence = []
+    
+    # 默认参数
+    dry_temp = 60.0  # 默认干燥温度 60°C
+    dry_time = 3600.0  # 默认干燥时间 1小时（3600秒）
+    simulation_time = 60.0  # 模拟时间 1分钟
+    
+    print(f"🌡️ DRY: 开始生成干燥协议 ✨")
+    print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    print(f"  🧪 化合物: {compound or '未指定'}")
+    print(f"  🔥 干燥温度: {dry_temp}°C")
+    print(f"  ⏰ 干燥时间: {dry_time/60:.0f} 分钟")
+    
+    # 🔧 新增：记录干燥前的容器状态
+    print(f"🔍 记录干燥前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    print(f"📊 干燥前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # 1. 验证目标容器存在
+    print(f"\n📋 步骤1: 验证目标容器 '{vessel_id}' 是否存在...")
+    if vessel_id not in G.nodes():
+        print(f"⚠️ DRY: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过干燥 😢")
+        return action_sequence
+    print(f"✅ 容器 '{vessel_id}' 验证通过!")
+    
+    # 2. 查找相连的加热器
+    print(f"\n🔍 步骤2: 查找与容器相连的加热器...")
+    heater_id = find_connected_heater(G, vessel_id)  # 🔧 使用 vessel_id
+    
+    if heater_id is None:
+        print(f"😭 DRY: 警告 - 未找到与容器 '{vessel_id}' 相连的加热器，跳过干燥")
+        print(f"🎭 添加模拟干燥动作...")
+        # 添加一个等待动作，表示干燥过程（模拟）
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 10.0,  # 模拟等待时间
+                "description": f"模拟干燥 {compound or '化合物'} (无加热器可用)"
+            }
+        })
+        
+        # 🔧 新增：模拟干燥的体积变化（溶剂蒸发）
+        print(f"🔧 模拟干燥过程的体积减少...")
+        if original_liquid_volume > 0:
+            # 假设干燥过程中损失10%的体积（溶剂蒸发）
+            volume_loss = original_liquid_volume * 0.1
+            new_volume = max(0.0, original_liquid_volume - volume_loss)
+            
+            # 更新vessel字典中的体积
+            if "data" in vessel and "liquid_volume" in vessel["data"]:
+                current_volume = vessel["data"]["liquid_volume"]
+                if isinstance(current_volume, list):
+                    if len(current_volume) > 0:
+                        vessel["data"]["liquid_volume"][0] = new_volume
+                    else:
+                        vessel["data"]["liquid_volume"] = [new_volume]
+                elif isinstance(current_volume, (int, float)):
+                    vessel["data"]["liquid_volume"] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = new_volume
+            
+            # 🔧 同时更新图中的容器数据
+            if vessel_id in G.nodes():
+                if 'data' not in G.nodes[vessel_id]:
+                    G.nodes[vessel_id]['data'] = {}
+                
+                vessel_node_data = G.nodes[vessel_id]['data']
+                current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+                
+                if isinstance(current_node_volume, list):
+                    if len(current_node_volume) > 0:
+                        G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+                    else:
+                        G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+            
+            print(f"📊 模拟干燥体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{volume_loss:.2f}mL)")
+        
+        print(f"📄 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
+        return action_sequence
+    
+    print(f"🎉 找到加热器: {heater_id}!")
+    
+    # 3. 启动加热器进行干燥
+    print(f"\n🚀 步骤3: 开始执行干燥流程...")
+    print(f"🔥 启动加热器 {heater_id} 进行干燥")
+    
+    # 3.1 启动加热
+    print(f"  ⚡ 动作1: 启动加热到 {dry_temp}°C...")
+    action_sequence.append({
+        "device_id": heater_id,
+        "action_name": "heat_chill_start",
+        "action_kwargs": {
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "temp": dry_temp,
+            "purpose": f"干燥 {compound or '化合物'}"
+        }
+    })
+    print(f"  ✅ 加热器启动命令已添加 🔥")
+    
+    # 3.2 等待温度稳定
+    print(f"  ⏳ 动作2: 等待温度稳定...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 10.0,
+            "description": f"等待温度稳定到 {dry_temp}°C"
+        }
+    })
+    print(f"  ✅ 温度稳定等待命令已添加 🌡️")
+    
+    # 3.3 保持干燥温度
+    print(f"  🔄 动作3: 保持干燥温度 {simulation_time/60:.0f} 分钟...")
+    action_sequence.append({
+        "device_id": heater_id,
+        "action_name": "heat_chill",
+        "action_kwargs": {
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "temp": dry_temp,
+            "time": simulation_time,
+            "purpose": f"干燥 {compound or '化合物'}，保持温度 {dry_temp}°C"
+        }
+    })
+    print(f"  ✅ 温度保持命令已添加 🌡️⏰")
+    
+    # 🔧 新增：干燥过程中的体积变化计算
+    print(f"🔧 计算干燥过程中的体积变化...")
+    if original_liquid_volume > 0:
+        # 干燥过程中，溶剂会蒸发，固体保留
+        # 根据温度和时间估算蒸发量
+        evaporation_rate = 0.001 * dry_temp  # 每秒每°C蒸发0.001mL
+        total_evaporation = min(original_liquid_volume * 0.8, 
+                               evaporation_rate * simulation_time)  # 最多蒸发80%
+        
+        new_volume = max(0.0, original_liquid_volume - total_evaporation)
+        
+        # 更新vessel字典中的体积
+        if "data" in vessel and "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            elif isinstance(current_volume, (int, float)):
+                vessel["data"]["liquid_volume"] = new_volume
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        
+        # 🔧 同时更新图中的容器数据
+        if vessel_id in G.nodes():
+            if 'data' not in G.nodes[vessel_id]:
+                G.nodes[vessel_id]['data'] = {}
+            
+            vessel_node_data = G.nodes[vessel_id]['data']
+            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+            
+            if isinstance(current_node_volume, list):
+                if len(current_node_volume) > 0:
+                    G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+        
+        print(f"📊 干燥体积变化计算:")
+        print(f"  - 初始体积: {original_liquid_volume:.2f}mL")
+        print(f"  - 蒸发量: {total_evaporation:.2f}mL")
+        print(f"  - 剩余体积: {new_volume:.2f}mL")
+        print(f"  - 蒸发率: {(total_evaporation/original_liquid_volume*100):.1f}%")
+    
+    # 3.4 停止加热
+    print(f"  ⏹️ 动作4: 停止加热...")
+    action_sequence.append({
+        "device_id": heater_id,
+        "action_name": "heat_chill_stop",
+        "action_kwargs": {
+            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "purpose": f"干燥完成，停止加热"
+        }
+    })
+    print(f"  ✅ 停止加热命令已添加 🛑")
+    
+    # 3.5 等待冷却
+    print(f"  ❄️ 动作5: 等待冷却...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 10.0,  # 等待10秒冷却
+            "description": f"等待 {compound or '化合物'} 冷却"
+        }
+    })
+    print(f"  ✅ 冷却等待命令已添加 🧊")
+    
+    # 🔧 新增：干燥完成后的状态报告
+    final_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    print(f"\n🎊 DRY: 协议生成完成，共 {len(action_sequence)} 个动作 🎯")
+    print(f"⏱️ DRY: 预计总时间: {(simulation_time + 30)/60:.0f} 分钟 ⌛")
+    print(f"📊 干燥结果:")
+    print(f"  - 容器: {vessel_id}")
+    print(f"  - 化合物: {compound or '未指定'}")
+    print(f"  - 干燥前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 干燥后体积: {final_liquid_volume:.2f}mL")
+    print(f"  - 蒸发体积: {(original_liquid_volume - final_liquid_volume):.2f}mL")
+    print(f"🏁 所有动作序列准备就绪! ✨")
+    
+    return action_sequence
+
+
+# 🔧 新增：便捷函数
+def generate_quick_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
+                               temp: float = 40.0, time: float = 30.0) -> List[Dict[str, Any]]:
+    """快速干燥：低温短时间"""
+    vessel_id = vessel["id"]
+    print(f"🌡️ 快速干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
+    
+    # 临时修改默认参数
+    import types
+    temp_func = types.FunctionType(
+        generate_dry_protocol.__code__, 
+        generate_dry_protocol.__globals__
+    )
+    
+    # 直接调用原函数，但修改内部参数
+    return generate_dry_protocol(G, vessel, compound)
+
+
+def generate_thorough_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
+                                  temp: float = 80.0, time: float = 120.0) -> List[Dict[str, Any]]:
+    """深度干燥：高温长时间"""
+    vessel_id = vessel["id"]
+    print(f"🔥 深度干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
+    return generate_dry_protocol(G, vessel, compound)
+
+
+def generate_gentle_dry_protocol(G: nx.DiGraph, vessel: dict, compound: str = "", 
+                                temp: float = 30.0, time: float = 180.0) -> List[Dict[str, Any]]:
+    """温和干燥：低温长时间"""
+    vessel_id = vessel["id"]
+    print(f"🌡️ 温和干燥: {compound or '化合物'} → {vessel_id} @ {temp}°C ({time}min)")
+    return generate_dry_protocol(G, vessel, compound)
+
+
+# 测试函数
+def test_dry_protocol():
+    """测试干燥协议"""
+    print("=== DRY PROTOCOL 测试 ===")
+    print("测试完成")
+
+
+if __name__ == "__main__":
+    test_dry_protocol()

unilabos/compile/evacuateandrefill_protocol.py

@@ -1,143 +1,752 @@
-import numpy as np
-import networkx as nx
+from functools import partial
 
+import networkx as nx
+import logging
+import uuid
+import sys
+from typing import List, Dict, Any, Optional
+from .utils.vessel_parser import get_vessel
+from .utils.logger_util import action_log
+from .pump_protocol import generate_pump_protocol_with_rinsing, generate_pump_protocol
+
+# 设置日志
+logger = logging.getLogger(__name__)
+
+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        logger.info(f"[抽真空充气] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        logger.info(f"[抽真空充气] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        logger.info(f"[抽真空充气] {fallback_message}")
+
+create_action_log = partial(action_log, prefix="[抽真空充气]")
+
+def find_gas_source(G: nx.DiGraph, gas: str) -> str:
+    """
+    根据气体名称查找对应的气源，支持多种匹配模式：
+    1. 容器名称匹配
+    2. 气体类型匹配（data.gas_type）
+    3. 默认气源
+    """
+    debug_print(f"🔍 正在查找气体 '{gas}' 的气源...")
+    
+    # 第一步：通过容器名称匹配
+    debug_print(f"📋 方法1: 容器名称匹配...")
+    gas_source_patterns = [
+        f"gas_source_{gas}",
+        f"gas_{gas}",
+        f"flask_{gas}",
+        f"{gas}_source",
+        f"source_{gas}",
+        f"reagent_bottle_{gas}",
+        f"bottle_{gas}"
+    ]
+    
+    debug_print(f"🎯 尝试的容器名称: {gas_source_patterns}")
+    
+    for pattern in gas_source_patterns:
+        if pattern in G.nodes():
+            debug_print(f"✅ 通过名称找到气源: {pattern}")
+            return pattern
+    
+    # 第二步：通过气体类型匹配 (data.gas_type)
+    debug_print(f"📋 方法2: 气体类型匹配...")
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        node_class = node_data.get('class', '') or ''
+        
+        # 检查是否是气源设备
+        if ('gas_source' in node_class or 
+            'gas' in node_id.lower() or 
+            node_id.startswith('flask_')):
+            
+            # 检查 data.gas_type
+            data = node_data.get('data', {})
+            gas_type = data.get('gas_type', '')
+            
+            if gas_type.lower() == gas.lower():
+                debug_print(f"✅ 通过气体类型找到气源: {node_id} (气体类型: {gas_type})")
+                return node_id
+            
+            # 检查 config.gas_type  
+            config = node_data.get('config', {})
+            config_gas_type = config.get('gas_type', '')
+            
+            if config_gas_type.lower() == gas.lower():
+                debug_print(f"✅ 通过配置气体类型找到气源: {node_id} (配置气体类型: {config_gas_type})")
+                return node_id
+    
+    # 第三步：查找所有可用的气源设备
+    debug_print(f"📋 方法3: 查找可用气源...")
+    available_gas_sources = []
+    for node_id in G.nodes():
+        node_data = G.nodes[node_id]
+        node_class = node_data.get('class', '') or ''
+        
+        if ('gas_source' in node_class or 
+            'gas' in node_id.lower() or
+            (node_id.startswith('flask_') and any(g in node_id.lower() for g in ['air', 'nitrogen', 'argon']))):
+            
+            data = node_data.get('data', {})
+            gas_type = data.get('gas_type', '未知')
+            available_gas_sources.append(f"{node_id} (气体类型: {gas_type})")
+    
+    debug_print(f"📊 可用气源: {available_gas_sources}")
+    
+    # 第四步：如果找不到特定气体，使用默认的第一个气源
+    debug_print(f"📋 方法4: 查找默认气源...")
+    default_gas_sources = [
+        node for node in G.nodes() 
+        if ((G.nodes[node].get('class') or '').find('virtual_gas_source') != -1
+            or 'gas_source' in node)
+    ]
+    
+    if default_gas_sources:
+        default_source = default_gas_sources[0]
+        debug_print(f"⚠️ 未找到特定气体 '{gas}'，使用默认气源: {default_source}")
+        return default_source
+    
+    debug_print(f"❌ 所有方法都失败了！")
+    raise ValueError(f"无法找到气体 '{gas}' 的气源。可用气源: {available_gas_sources}")
+
+def find_vacuum_pump(G: nx.DiGraph) -> str:
+    """查找真空泵设备"""
+    debug_print("🔍 正在查找真空泵...")
+    
+    vacuum_pumps = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if ('virtual_vacuum_pump' in node_class or 
+            'vacuum_pump' in node.lower() or 
+            'vacuum' in node_class.lower()):
+            vacuum_pumps.append(node)
+            debug_print(f"📋 发现真空泵: {node}")
+    
+    if not vacuum_pumps:
+        debug_print(f"❌ 系统中未找到真空泵")
+        raise ValueError("系统中未找到真空泵")
+    
+    debug_print(f"✅ 使用真空泵: {vacuum_pumps[0]}")
+    return vacuum_pumps[0]
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str) -> Optional[str]:
+    """查找与指定容器相连的搅拌器"""
+    debug_print(f"🔍 正在查找与容器 {vessel} 连接的搅拌器...")
+    
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'virtual_stirrer' in node_class or 'stirrer' in node.lower():
+            stirrer_nodes.append(node)
+            debug_print(f"📋 发现搅拌器: {node}")
+    
+    debug_print(f"📊 找到的搅拌器总数: {len(stirrer_nodes)}")
+    
+    # 检查哪个搅拌器与目标容器相连
+    for stirrer in stirrer_nodes:
+        if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+            debug_print(f"✅ 找到连接的搅拌器: {stirrer}")
+            return stirrer
+    
+    # 如果没有连接的搅拌器，返回第一个可用的
+    if stirrer_nodes:
+        debug_print(f"⚠️ 未找到直接连接的搅拌器，使用第一个可用的: {stirrer_nodes[0]}")
+        return stirrer_nodes[0]
+    
+    debug_print("❌ 未找到搅拌器")
+    return None
+
+def find_vacuum_solenoid_valve(G: nx.DiGraph, vacuum_pump: str) -> Optional[str]:
+    """查找真空泵相关的电磁阀"""
+    debug_print(f"🔍 正在查找真空泵 {vacuum_pump} 的电磁阀...")
+    
+    # 查找所有电磁阀
+    solenoid_valves = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if ('solenoid' in node_class.lower() or 'solenoid_valve' in node.lower()):
+            solenoid_valves.append(node)
+            debug_print(f"📋 发现电磁阀: {node}")
+    
+    debug_print(f"📊 找到的电磁阀: {solenoid_valves}")
+    
+    # 检查连接关系
+    debug_print(f"📋 方法1: 检查连接关系...")
+    for solenoid in solenoid_valves:
+        if G.has_edge(solenoid, vacuum_pump) or G.has_edge(vacuum_pump, solenoid):
+            debug_print(f"✅ 找到连接的真空电磁阀: {solenoid}")
+            return solenoid
+    
+    # 通过命名规则查找
+    debug_print(f"📋 方法2: 检查命名规则...")
+    for solenoid in solenoid_valves:
+        if 'vacuum' in solenoid.lower() or solenoid == 'solenoid_valve_1':
+            debug_print(f"✅ 通过命名找到真空电磁阀: {solenoid}")
+            return solenoid
+    
+    debug_print("⚠️ 未找到真空电磁阀")
+    return None
+
+def find_gas_solenoid_valve(G: nx.DiGraph, gas_source: str) -> Optional[str]:
+    """查找气源相关的电磁阀"""
+    debug_print(f"🔍 正在查找气源 {gas_source} 的电磁阀...")
+    
+    # 查找所有电磁阀
+    solenoid_valves = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if ('solenoid' in node_class.lower() or 'solenoid_valve' in node.lower()):
+            solenoid_valves.append(node)
+    
+    debug_print(f"📊 找到的电磁阀: {solenoid_valves}")
+    
+    # 检查连接关系
+    debug_print(f"📋 方法1: 检查连接关系...")
+    for solenoid in solenoid_valves:
+        if G.has_edge(gas_source, solenoid) or G.has_edge(solenoid, gas_source):
+            debug_print(f"✅ 找到连接的气源电磁阀: {solenoid}")
+            return solenoid
+    
+    # 通过命名规则查找
+    debug_print(f"📋 方法2: 检查命名规则...")
+    for solenoid in solenoid_valves:
+        if 'gas' in solenoid.lower() or solenoid == 'solenoid_valve_2':
+            debug_print(f"✅ 通过命名找到气源电磁阀: {solenoid}")
+            return solenoid
+    
+    debug_print("⚠️ 未找到气源电磁阀")
+    return None
 
 def generate_evacuateandrefill_protocol(
     G: nx.DiGraph,
-    vessel: str, 
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
     gas: str,
-    repeats: int = 1
-) -> list[dict]:
+    **kwargs
+) -> List[Dict[str, Any]]:
     """
-    生成泵操作的动作序列。
+    生成抽真空和充气操作的动作序列 - 中文版
     
-    :param G: 有向图, 节点为容器和注射泵, 边为流体管道, A→B边的属性为管道接A端的阀门位置
-    :param from_vessel: 容器A
-    :param to_vessel: 容器B
-    :param volume: 转移的体积
-    :param flowrate: 最终注入容器B时的流速
-    :param transfer_flowrate: 泵骨架中转移流速（若不指定，默认与注入流速相同）
-    :return: 泵操作的动作序列
+    Args:
+        G: 设备图
+        vessel: 目标容器字典（必需）
+        gas: 气体名称（必需）  
+        **kwargs: 其他参数（兼容性）
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
     """
     
-    # 生成电磁阀、真空泵、气源操作的动作序列
-    vacuum_action_sequence = []
-    nodes = G.nodes(data=True)
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
     
-    # 找到和 vessel 相连的电磁阀和真空泵、气源
-    vacuum_backbone = {"vessel": vessel}
+    # 硬编码重复次数为 3
+    repeats = 3
     
-    for neighbor in G.neighbors(vessel):
-        if nodes[neighbor]["class"].startswith("solenoid_valve"):
-            for neighbor2 in G.neighbors(neighbor):
-                if neighbor2 == vessel:
-                    continue
-                if nodes[neighbor2]["class"].startswith("vacuum_pump"):
-                    vacuum_backbone.update({"vacuum_valve": neighbor, "pump": neighbor2})
-                    break
-                elif nodes[neighbor2]["class"].startswith("gas_source"):
-                    vacuum_backbone.update({"gas_valve": neighbor, "gas": neighbor2})
-                    break
-    # 判断是否设备齐全
-    if len(vacuum_backbone) < 5:
-        print(f"\n\n\n{vacuum_backbone}\n\n\n")
-        raise ValueError("Not all devices are connected to the vessel.")
+    # 生成协议ID
+    protocol_id = str(uuid.uuid4())
+    debug_print(f"🆔 生成协议ID: {protocol_id}")
     
-    # 生成操作的动作序列
-    for i in range(repeats):
-        # 打开真空泵阀门、关闭气源阀门
-        vacuum_action_sequence.append([
-            {
-                "device_id": vacuum_backbone["vacuum_valve"],
-                "action_name": "set_valve_position",
-                "action_kwargs": {
-                    "command": "OPEN"
-                }
-            },
-            {
-                "device_id": vacuum_backbone["gas_valve"],
-                "action_name": "set_valve_position",
-                "action_kwargs": {
-                    "command": "CLOSED"
-                }
+    debug_print("=" * 60)
+    debug_print("🧪 开始生成抽真空充气协议")
+    debug_print(f"📋 原始参数:")
+    debug_print(f"  🥼 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  💨 气体: '{gas}'")
+    debug_print(f"  🔄 循环次数: {repeats} (硬编码)")
+    debug_print(f"  📦 其他参数: {kwargs}")
+    debug_print("=" * 60)
+    
+    action_sequence = []
+    
+    # === 参数验证和修正 ===
+    debug_print("🔍 步骤1: 参数验证和修正...")
+    action_sequence.append(create_action_log(f"开始抽真空充气操作 - 容器: {vessel_id}", "🎬"))
+    action_sequence.append(create_action_log(f"目标气体: {gas}", "💨"))
+    action_sequence.append(create_action_log(f"循环次数: {repeats}", "🔄"))
+    
+    # 验证必需参数
+    if not vessel_id:
+        debug_print("❌ 容器参数不能为空")
+        raise ValueError("容器参数不能为空")
+    
+    if not gas:
+        debug_print("❌ 气体参数不能为空")
+        raise ValueError("气体参数不能为空")
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 在系统中不存在")
+        raise ValueError(f"容器 '{vessel_id}' 在系统中不存在")
+    
+    debug_print("✅ 基本参数验证通过")
+    action_sequence.append(create_action_log("参数验证通过", "✅"))
+    
+    # 标准化气体名称
+    debug_print("🔧 标准化气体名称...")
+    gas_aliases = {
+        'n2': 'nitrogen',
+        'ar': 'argon',
+        'air': 'air',
+        'o2': 'oxygen',
+        'co2': 'carbon_dioxide',
+        'h2': 'hydrogen',
+        '氮气': 'nitrogen',
+        '氩气': 'argon',
+        '空气': 'air',
+        '氧气': 'oxygen',
+        '二氧化碳': 'carbon_dioxide',
+        '氢气': 'hydrogen'
+    }
+    
+    original_gas = gas
+    gas_lower = gas.lower().strip()
+    if gas_lower in gas_aliases:
+        gas = gas_aliases[gas_lower]
+        debug_print(f"🔄 标准化气体名称: {original_gas} -> {gas}")
+        action_sequence.append(create_action_log(f"气体名称标准化: {original_gas} -> {gas}", "🔄"))
+    
+    debug_print(f"📋 最终参数: 容器={vessel_id}, 气体={gas}, 重复={repeats}")
+    
+    # === 查找设备 ===
+    debug_print("🔍 步骤2: 查找设备...")
+    action_sequence.append(create_action_log("正在查找相关设备...", "🔍"))
+    
+    try:
+        vacuum_pump = find_vacuum_pump(G)
+        action_sequence.append(create_action_log(f"找到真空泵: {vacuum_pump}", "🌪️"))
+        
+        gas_source = find_gas_source(G, gas)
+        action_sequence.append(create_action_log(f"找到气源: {gas_source}", "💨"))
+        
+        vacuum_solenoid = find_vacuum_solenoid_valve(G, vacuum_pump)
+        if vacuum_solenoid:
+            action_sequence.append(create_action_log(f"找到真空电磁阀: {vacuum_solenoid}", "🚪"))
+        else:
+            action_sequence.append(create_action_log("未找到真空电磁阀", "⚠️"))
+        
+        gas_solenoid = find_gas_solenoid_valve(G, gas_source)
+        if gas_solenoid:
+            action_sequence.append(create_action_log(f"找到气源电磁阀: {gas_solenoid}", "🚪"))
+        else:
+            action_sequence.append(create_action_log("未找到气源电磁阀", "⚠️"))
+        
+        stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
+        if stirrer_id:
+            action_sequence.append(create_action_log(f"找到搅拌器: {stirrer_id}", "🌪️"))
+        else:
+            action_sequence.append(create_action_log("未找到搅拌器", "⚠️"))
+        
+        debug_print(f"📊 设备配置:")
+        debug_print(f"  🌪️ 真空泵: {vacuum_pump}")
+        debug_print(f"  💨 气源: {gas_source}")
+        debug_print(f"  🚪 真空电磁阀: {vacuum_solenoid}")
+        debug_print(f"  🚪 气源电磁阀: {gas_solenoid}")
+        debug_print(f"  🌪️ 搅拌器: {stirrer_id}")
+        
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)}")
+        action_sequence.append(create_action_log(f"设备查找失败: {str(e)}", "❌"))
+        raise ValueError(f"设备查找失败: {str(e)}")
+    
+    # === 参数设置 ===
+    debug_print("🔍 步骤3: 参数设置...")
+    action_sequence.append(create_action_log("设置操作参数...", "⚙️"))
+    
+    # 根据气体类型调整参数
+    if gas.lower() in ['nitrogen', 'argon']:
+        VACUUM_VOLUME = 25.0
+        REFILL_VOLUME = 25.0
+        PUMP_FLOW_RATE = 2.0
+        VACUUM_TIME = 30.0
+        REFILL_TIME = 20.0
+        debug_print("💨 惰性气体: 使用标准参数")
+        action_sequence.append(create_action_log("检测到惰性气体，使用标准参数", "💨"))
+    elif gas.lower() in ['air', 'oxygen']:
+        VACUUM_VOLUME = 20.0
+        REFILL_VOLUME = 20.0
+        PUMP_FLOW_RATE = 1.5
+        VACUUM_TIME = 45.0
+        REFILL_TIME = 25.0
+        debug_print("🔥 活性气体: 使用保守参数")
+        action_sequence.append(create_action_log("检测到活性气体，使用保守参数", "🔥"))
+    else:
+        VACUUM_VOLUME = 15.0
+        REFILL_VOLUME = 15.0
+        PUMP_FLOW_RATE = 1.0
+        VACUUM_TIME = 60.0
+        REFILL_TIME = 30.0
+        debug_print("❓ 未知气体: 使用安全参数")
+        action_sequence.append(create_action_log("未知气体类型，使用安全参数", "❓"))
+    
+    STIR_SPEED = 200.0
+    
+    debug_print(f"⚙️ 操作参数:")
+    debug_print(f"  📏 真空体积: {VACUUM_VOLUME}mL")
+    debug_print(f"  📏 充气体积: {REFILL_VOLUME}mL")
+    debug_print(f"  ⚡ 泵流速: {PUMP_FLOW_RATE}mL/s")
+    debug_print(f"  ⏱️ 真空时间: {VACUUM_TIME}s")
+    debug_print(f"  ⏱️ 充气时间: {REFILL_TIME}s")
+    debug_print(f"  🌪️ 搅拌速度: {STIR_SPEED}RPM")
+    
+    action_sequence.append(create_action_log(f"真空体积: {VACUUM_VOLUME}mL", "📏"))
+    action_sequence.append(create_action_log(f"充气体积: {REFILL_VOLUME}mL", "📏"))
+    action_sequence.append(create_action_log(f"泵流速: {PUMP_FLOW_RATE}mL/s", "⚡"))
+    
+    # === 路径验证 ===
+    debug_print("🔍 步骤4: 路径验证...")
+    action_sequence.append(create_action_log("验证传输路径...", "🛤️"))
+    
+    try:
+        # 验证抽真空路径
+        if nx.has_path(G, vessel_id, vacuum_pump):  # 🔧 使用 vessel_id
+            vacuum_path = nx.shortest_path(G, source=vessel_id, target=vacuum_pump)
+            debug_print(f"✅ 真空路径: {' -> '.join(vacuum_path)}")
+            action_sequence.append(create_action_log(f"真空路径: {' -> '.join(vacuum_path)}", "🛤️"))
+        else:
+            debug_print(f"⚠️ 真空路径不存在，继续执行但可能有问题")
+            action_sequence.append(create_action_log("真空路径检查: 路径不存在", "⚠️"))
+        
+        # 验证充气路径
+        if nx.has_path(G, gas_source, vessel_id):  # 🔧 使用 vessel_id
+            gas_path = nx.shortest_path(G, source=gas_source, target=vessel_id)
+            debug_print(f"✅ 气体路径: {' -> '.join(gas_path)}")
+            action_sequence.append(create_action_log(f"气体路径: {' -> '.join(gas_path)}", "🛤️"))
+        else:
+            debug_print(f"⚠️ 气体路径不存在，继续执行但可能有问题")
+            action_sequence.append(create_action_log("气体路径检查: 路径不存在", "⚠️"))
+        
+    except Exception as e:
+        debug_print(f"⚠️ 路径验证失败: {str(e)}，继续执行")
+        action_sequence.append(create_action_log(f"路径验证失败: {str(e)}", "⚠️"))
+    
+    # === 启动搅拌器 ===
+    debug_print("🔍 步骤5: 启动搅拌器...")
+    
+    if stirrer_id:
+        debug_print(f"🌪️ 启动搅拌器: {stirrer_id}")
+        action_sequence.append(create_action_log(f"启动搅拌器 {stirrer_id} (速度: {STIR_SPEED}rpm)", "🌪️"))
+        
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "start_stir",
+            "action_kwargs": {
+                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "stir_speed": STIR_SPEED,
+                "purpose": "抽真空充气前预搅拌"
             }
-        ])
+        })
         
-        # 打开真空泵、关闭气源
-        vacuum_action_sequence.append([
-            {
-                "device_id": vacuum_backbone["pump"],
-                "action_name": "set_status",
-                "action_kwargs": {
-                    "string": "ON"
-                }
-            },
-            {
-                "device_id": vacuum_backbone["gas"],
-                "action_name": "set_status",
-                "action_kwargs": {
-                    "string": "OFF"
-                }
-            }
-        ])
-        vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        # 等待搅拌稳定
+        action_sequence.append(create_action_log("等待搅拌稳定...", "⏳"))
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": 5.0}
+        })
+    else:
+        debug_print("⚠️ 未找到搅拌器，跳过搅拌器启动")
+        action_sequence.append(create_action_log("跳过搅拌器启动", "⏭️"))
     
-        # 关闭真空泵阀门、打开气源阀门
-        vacuum_action_sequence.append([
-            {
-                "device_id": vacuum_backbone["vacuum_valve"],
+    # === 执行循环 ===
+    debug_print("🔍 步骤6: 执行抽真空-充气循环...")
+    action_sequence.append(create_action_log(f"开始 {repeats} 次抽真空-充气循环", "🔄"))
+    
+    for cycle in range(repeats):
+        debug_print(f"=== 第 {cycle+1}/{repeats} 轮循环 ===")
+        action_sequence.append(create_action_log(f"第 {cycle+1}/{repeats} 轮循环开始", "🚀"))
+        
+        # ============ 抽真空阶段 ============
+        debug_print(f"🌪️ 抽真空阶段开始")
+        action_sequence.append(create_action_log("开始抽真空阶段", "🌪️"))
+        
+        # 启动真空泵
+        debug_print(f"🔛 启动真空泵: {vacuum_pump}")
+        action_sequence.append(create_action_log(f"启动真空泵: {vacuum_pump}", "🔛"))
+        action_sequence.append({
+            "device_id": vacuum_pump,
+            "action_name": "set_status",
+            "action_kwargs": {"string": "ON"}
+        })
+        
+        # 开启真空电磁阀
+        if vacuum_solenoid:
+            debug_print(f"🚪 打开真空电磁阀: {vacuum_solenoid}")
+            action_sequence.append(create_action_log(f"打开真空电磁阀: {vacuum_solenoid}", "🚪"))
+            action_sequence.append({
+                "device_id": vacuum_solenoid,
                 "action_name": "set_valve_position",
-                "action_kwargs": {
-                    "command": "CLOSED"
-                }
-            },
-            {
-                "device_id": vacuum_backbone["gas_valve"],
-                "action_name": "set_valve_position",
-                "action_kwargs": {
-                    "command": "OPEN"
-                }
-            }
-        ])
+                "action_kwargs": {"command": "OPEN"}
+            })
         
-        # 关闭真空泵、打开气源
-        vacuum_action_sequence.append([
-            {
-                "device_id": vacuum_backbone["pump"],
-                "action_name": "set_status",
-                "action_kwargs": {
-                    "string": "OFF"
-                }
-            },
-            {
-                "device_id": vacuum_backbone["gas"],
-                "action_name": "set_status",
-                "action_kwargs": {
-                    "string": "ON"
-                }
-            }
-        ])
-        vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        # 抽真空操作
+        debug_print(f"🌪️ 抽真空操作: {vessel_id} -> {vacuum_pump}")
+        action_sequence.append(create_action_log(f"开始抽真空: {vessel_id} -> {vacuum_pump}", "🌪️"))
+        
+        try:
+            vacuum_transfer_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=vessel_id,  # 🔧 使用 vessel_id
+                to_vessel=vacuum_pump,
+                volume=VACUUM_VOLUME,
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=PUMP_FLOW_RATE,
+                transfer_flowrate=PUMP_FLOW_RATE
+            )
+            
+            if vacuum_transfer_actions:
+                action_sequence.extend(vacuum_transfer_actions)
+                debug_print(f"✅ 添加了 {len(vacuum_transfer_actions)} 个抽真空动作")
+                action_sequence.append(create_action_log(f"抽真空协议完成 ({len(vacuum_transfer_actions)} 个操作)", "✅"))
+            else:
+                debug_print("⚠️ 抽真空协议返回空序列，添加手动动作")
+                action_sequence.append(create_action_log("抽真空协议为空，使用手动等待", "⚠️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": VACUUM_TIME}
+                })
+                
+        except Exception as e:
+            debug_print(f"❌ 抽真空失败: {str(e)}")
+            action_sequence.append(create_action_log(f"抽真空失败: {str(e)}", "❌"))
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {"time": VACUUM_TIME}
+            })
+        
+        # 抽真空后等待
+        wait_minutes = VACUUM_TIME / 60
+        action_sequence.append(create_action_log(f"抽真空后等待 ({wait_minutes:.1f} 分钟)", "⏳"))
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": VACUUM_TIME}
+        })
+        
+        # 关闭真空电磁阀
+        if vacuum_solenoid:
+            debug_print(f"🚪 关闭真空电磁阀: {vacuum_solenoid}")
+            action_sequence.append(create_action_log(f"关闭真空电磁阀: {vacuum_solenoid}", "🚪"))
+            action_sequence.append({
+                "device_id": vacuum_solenoid,
+                "action_name": "set_valve_position",
+                "action_kwargs": {"command": "CLOSED"}
+            })
+        
+        # 关闭真空泵
+        debug_print(f"🔴 停止真空泵: {vacuum_pump}")
+        action_sequence.append(create_action_log(f"停止真空泵: {vacuum_pump}", "🔴"))
+        action_sequence.append({
+            "device_id": vacuum_pump,
+            "action_name": "set_status",
+            "action_kwargs": {"string": "OFF"}
+        })
+        
+        # 阶段间等待
+        action_sequence.append(create_action_log("抽真空阶段完成，短暂等待", "⏳"))
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": 5.0}
+        })
+        
+        # ============ 充气阶段 ============
+        debug_print(f"💨 充气阶段开始")
+        action_sequence.append(create_action_log("开始气体充气阶段", "💨"))
+        
+        # 启动气源
+        debug_print(f"🔛 启动气源: {gas_source}")
+        action_sequence.append(create_action_log(f"启动气源: {gas_source}", "🔛"))
+        action_sequence.append({
+            "device_id": gas_source,
+            "action_name": "set_status",
+            "action_kwargs": {"string": "ON"}
+        })
+        
+        # 开启气源电磁阀
+        if gas_solenoid:
+            debug_print(f"🚪 打开气源电磁阀: {gas_solenoid}")
+            action_sequence.append(create_action_log(f"打开气源电磁阀: {gas_solenoid}", "🚪"))
+            action_sequence.append({
+                "device_id": gas_solenoid,
+                "action_name": "set_valve_position",
+                "action_kwargs": {"command": "OPEN"}
+            })
+        
+        # 充气操作
+        debug_print(f"💨 充气操作: {gas_source} -> {vessel_id}")
+        action_sequence.append(create_action_log(f"开始气体充气: {gas_source} -> {vessel_id}", "💨"))
+        
+        try:
+            gas_transfer_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=gas_source,
+                to_vessel=vessel_id,  # 🔧 使用 vessel_id
+                volume=REFILL_VOLUME,
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=PUMP_FLOW_RATE,
+                transfer_flowrate=PUMP_FLOW_RATE
+            )
+            
+            if gas_transfer_actions:
+                action_sequence.extend(gas_transfer_actions)
+                debug_print(f"✅ 添加了 {len(gas_transfer_actions)} 个充气动作")
+                action_sequence.append(create_action_log(f"气体充气协议完成 ({len(gas_transfer_actions)} 个操作)", "✅"))
+            else:
+                debug_print("⚠️ 充气协议返回空序列，添加手动动作")
+                action_sequence.append(create_action_log("充气协议为空，使用手动等待", "⚠️"))
+                action_sequence.append({
+                    "action_name": "wait",
+                    "action_kwargs": {"time": REFILL_TIME}
+                })
+                
+        except Exception as e:
+            debug_print(f"❌ 气体充气失败: {str(e)}")
+            action_sequence.append(create_action_log(f"气体充气失败: {str(e)}", "❌"))
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {"time": REFILL_TIME}
+            })
+        
+        # 充气后等待
+        refill_wait_minutes = REFILL_TIME / 60
+        action_sequence.append(create_action_log(f"充气后等待 ({refill_wait_minutes:.1f} 分钟)", "⏳"))
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": REFILL_TIME}
+        })
+        
+        # 关闭气源电磁阀
+        if gas_solenoid:
+            debug_print(f"🚪 关闭气源电磁阀: {gas_solenoid}")
+            action_sequence.append(create_action_log(f"关闭气源电磁阀: {gas_solenoid}", "🚪"))
+            action_sequence.append({
+                "device_id": gas_solenoid,
+                "action_name": "set_valve_position",
+                "action_kwargs": {"command": "CLOSED"}
+            })
         
         # 关闭气源
-        vacuum_action_sequence.append(
-            {
-                "device_id": vacuum_backbone["gas"],
-                "action_name": "set_status",
-                "action_kwargs": {
-                    "string": "OFF"
-                }
-            }
-        )
+        debug_print(f"🔴 停止气源: {gas_source}")
+        action_sequence.append(create_action_log(f"停止气源: {gas_source}", "🔴"))
+        action_sequence.append({
+            "device_id": gas_source,
+            "action_name": "set_status",
+            "action_kwargs": {"string": "OFF"}
+        })
         
-        # 关闭阀门
-        vacuum_action_sequence.append(
-            {
-                "device_id": vacuum_backbone["gas_valve"],
-                "action_name": "set_valve_position",
-                "action_kwargs": {
-                    "command": "CLOSED"
-                }
-            }
-        )
-    return vacuum_action_sequence
+        # 循环间等待
+        if cycle < repeats - 1:
+            debug_print(f"⏳ 等待下一个循环...")
+            action_sequence.append(create_action_log("等待下一个循环...", "⏳"))
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {"time": 10.0}
+            })
+        else:
+            action_sequence.append(create_action_log(f"第 {cycle+1}/{repeats} 轮循环完成", "✅"))
+    
+    # === 停止搅拌器 ===
+    debug_print("🔍 步骤7: 停止搅拌器...")
+    
+    if stirrer_id:
+        debug_print(f"🛑 停止搅拌器: {stirrer_id}")
+        action_sequence.append(create_action_log(f"停止搅拌器: {stirrer_id}", "🛑"))
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "stop_stir",
+            "action_kwargs": {"vessel": {"id": vessel_id},}  # 🔧 使用 vessel_id
+        })
+    else:
+        action_sequence.append(create_action_log("跳过搅拌器停止", "⏭️"))
+    
+    # === 最终等待 ===
+    action_sequence.append(create_action_log("最终稳定等待...", "⏳"))
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {"time": 10.0}
+    })
+    
+    # === 总结 ===
+    total_time = (VACUUM_TIME + REFILL_TIME + 25) * repeats + 20
+    
+    debug_print("=" * 60)
+    debug_print(f"🎉 抽真空充气协议生成完成")
+    debug_print(f"📊 协议统计:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)}")
+    debug_print(f"  ⏱️ 预计总时间: {total_time:.0f}s ({total_time/60:.1f} 分钟)")
+    debug_print(f"  🥼 处理容器: {vessel_id}")
+    debug_print(f"  💨 使用气体: {gas}")
+    debug_print(f"  🔄 重复次数: {repeats}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"抽真空充气协议完成: {vessel_id} (使用 {gas}，{repeats} 次循环)"
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+
+# === 便捷函数 ===
+
+def generate_nitrogen_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
+    """生成氮气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成氮气置换协议: {vessel_id}")
+    return generate_evacuateandrefill_protocol(G, vessel, "nitrogen", **kwargs)
+
+def generate_argon_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
+    """生成氩气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成氩气置换协议: {vessel_id}")
+    return generate_evacuateandrefill_protocol(G, vessel, "argon", **kwargs)
+
+def generate_air_purge_protocol(G: nx.DiGraph, vessel: dict, **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
+    """生成空气置换协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"💨 生成空气置换协议: {vessel_id}")
+    return generate_evacuateandrefill_protocol(G, vessel, "air", **kwargs)
+
+def generate_inert_atmosphere_protocol(G: nx.DiGraph, vessel: dict, gas: str = "nitrogen", **kwargs) -> List[Dict[str, Any]]:  # 🔧 修改参数类型
+    """生成惰性气氛协议"""
+    vessel_id = vessel["id"]
+    debug_print(f"🛡️ 生成惰性气氛协议: {vessel_id} (使用 {gas})")
+    return generate_evacuateandrefill_protocol(G, vessel, gas, **kwargs)
+
+# 测试函数
+def test_evacuateandrefill_protocol():
+    """测试抽真空充气协议"""
+    debug_print("=== 抽真空充气协议增强中文版测试 ===")
+    debug_print("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_evacuateandrefill_protocol()

unilabos/compile/evacuateandrefill_protocol_old.py

@@ -0,0 +1,143 @@
+# import numpy as np
+# import networkx as nx
+
+
+# def generate_evacuateandrefill_protocol(
+#     G: nx.DiGraph, 
+#     vessel: str, 
+#     gas: str, 
+#     repeats: int = 1
+# ) -> list[dict]:
+#     """
+#     生成泵操作的动作序列。
+    
+#     :param G: 有向图, 节点为容器和注射泵, 边为流体管道, A→B边的属性为管道接A端的阀门位置
+#     :param from_vessel: 容器A
+#     :param to_vessel: 容器B
+#     :param volume: 转移的体积
+#     :param flowrate: 最终注入容器B时的流速
+#     :param transfer_flowrate: 泵骨架中转移流速（若不指定，默认与注入流速相同）
+#     :return: 泵操作的动作序列
+#     """
+    
+#     # 生成电磁阀、真空泵、气源操作的动作序列
+#     vacuum_action_sequence = []
+#     nodes = G.nodes(data=True)
+    
+#     # 找到和 vessel 相连的电磁阀和真空泵、气源
+#     vacuum_backbone = {"vessel": vessel}
+    
+#     for neighbor in G.neighbors(vessel):
+#         if nodes[neighbor]["class"].startswith("solenoid_valve"):
+#             for neighbor2 in G.neighbors(neighbor):
+#                 if neighbor2 == vessel:
+#                     continue
+#                 if nodes[neighbor2]["class"].startswith("vacuum_pump"):
+#                     vacuum_backbone.update({"vacuum_valve": neighbor, "pump": neighbor2})
+#                     break
+#                 elif nodes[neighbor2]["class"].startswith("gas_source"):
+#                     vacuum_backbone.update({"gas_valve": neighbor, "gas": neighbor2})
+#                     break
+#     # 判断是否设备齐全
+#     if len(vacuum_backbone) < 5:
+#         print(f"\n\n\n{vacuum_backbone}\n\n\n")
+#         raise ValueError("Not all devices are connected to the vessel.")
+    
+#     # 生成操作的动作序列
+#     for i in range(repeats):
+#         # 打开真空泵阀门、关闭气源阀门
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["vacuum_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "OPEN"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             }
+#         ])
+        
+#         # 打开真空泵、关闭气源
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["pump"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "ON"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             }
+#         ])
+#         vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        
+#         # 关闭真空泵阀门、打开气源阀门
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["vacuum_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "OPEN"
+#                 }
+#             }
+#         ])
+        
+#         # 关闭真空泵、打开气源
+#         vacuum_action_sequence.append([
+#             {
+#                 "device_id": vacuum_backbone["pump"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             },
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "ON"
+#                 }
+#             }
+#         ])
+#         vacuum_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 60}})
+        
+#         # 关闭气源
+#         vacuum_action_sequence.append(
+#             {
+#                 "device_id": vacuum_backbone["gas"],
+#                 "action_name": "set_status",
+#                 "action_kwargs": {
+#                     "string": "OFF"
+#                 }
+#             }
+#         )
+        
+#         # 关闭阀门
+#         vacuum_action_sequence.append(
+#             {
+#                 "device_id": vacuum_backbone["gas_valve"],
+#                 "action_name": "set_valve_position",
+#                 "action_kwargs": {
+#                     "command": "CLOSED"
+#                 }
+#             }
+#         )
+#     return vacuum_action_sequence

unilabos/compile/evaporate_protocol.py

@@ -1,81 +1,410 @@
-import numpy as np
+from typing import List, Dict, Any, Optional, Union
 import networkx as nx
+import logging
+import re
+from .utils.vessel_parser import get_vessel
+from .utils.unit_parser import parse_time_input
 
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[EVAPORATE] {message}")
+
+
+def find_rotavap_device(G: nx.DiGraph, vessel: str = None) -> Optional[str]:
+    """
+    在组态图中查找旋转蒸发仪设备
+    
+    Args:
+        G: 设备图
+        vessel: 指定的设备名称（可选）
+    
+    Returns:
+        str: 找到的旋转蒸发仪设备ID，如果没找到返回None
+    """
+    debug_print("🔍 开始查找旋转蒸发仪设备... 🌪️")
+    
+    # 如果指定了vessel，先检查是否存在且是旋转蒸发仪
+    if vessel:
+        debug_print(f"🎯 检查指定设备: {vessel} 🔧")
+        if vessel in G.nodes():
+            node_data = G.nodes[vessel]
+            node_class = node_data.get('class', '')
+            node_type = node_data.get('type', '')
+            
+            debug_print(f"📋 设备信息 {vessel}: class={node_class}, type={node_type}")
+            
+            # 检查是否为旋转蒸发仪
+            if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+                debug_print(f"🎉 找到指定的旋转蒸发仪: {vessel} ✨")
+                return vessel
+            elif node_type == 'device':
+                debug_print(f"✅ 指定设备存在，尝试直接使用: {vessel} 🔧")
+                return vessel
+        else:
+            debug_print(f"❌ 指定的设备 {vessel} 不存在 😞")
+    
+    # 在所有设备中查找旋转蒸发仪
+    debug_print("🔎 在所有设备中搜索旋转蒸发仪... 🕵️‍♀️")
+    rotavap_candidates = []
+    
+    for node_id, node_data in G.nodes(data=True):
+        node_class = node_data.get('class', '')
+        node_type = node_data.get('type', '')
+        
+        # 跳过非设备节点
+        if node_type != 'device':
+            continue
+            
+        # 检查设备类型
+        if any(keyword in str(node_class).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+            rotavap_candidates.append(node_id)
+            debug_print(f"🌟 找到旋转蒸发仪候选: {node_id} (class: {node_class}) 🌪️")
+        elif any(keyword in str(node_id).lower() for keyword in ['rotavap', 'rotary', 'evaporat']):
+            rotavap_candidates.append(node_id)
+            debug_print(f"🌟 找到旋转蒸发仪候选 (按名称): {node_id} 🌪️")
+    
+    if rotavap_candidates:
+        selected = rotavap_candidates[0]  # 选择第一个找到的
+        debug_print(f"🎯 选择旋转蒸发仪: {selected} 🏆")
+        return selected
+    
+    debug_print("😭 未找到旋转蒸发仪设备 💔")
+    return None
+
+def find_connected_vessel(G: nx.DiGraph, rotavap_device: str) -> Optional[str]:
+    """
+    查找与旋转蒸发仪连接的容器
+    
+    Args:
+        G: 设备图
+        rotavap_device: 旋转蒸发仪设备ID
+    
+    Returns:
+        str: 连接的容器ID，如果没找到返回None
+    """
+    debug_print(f"🔗 查找与 {rotavap_device} 连接的容器... 🥽")
+    
+    # 查看旋转蒸发仪的子设备
+    rotavap_data = G.nodes[rotavap_device]
+    children = rotavap_data.get('children', [])
+    
+    debug_print(f"👶 检查子设备: {children}")
+    for child_id in children:
+        if child_id in G.nodes():
+            child_data = G.nodes[child_id]
+            child_type = child_data.get('type', '')
+            
+            if child_type == 'container':
+                debug_print(f"🎉 找到连接的容器: {child_id} 🥽✨")
+                return child_id
+    
+    # 查看邻接的容器
+    debug_print("🤝 检查邻接设备...")
+    for neighbor in G.neighbors(rotavap_device):
+        neighbor_data = G.nodes[neighbor]
+        neighbor_type = neighbor_data.get('type', '')
+        
+        if neighbor_type == 'container':
+            debug_print(f"🎉 找到邻接的容器: {neighbor} 🥽✨")
+            return neighbor
+    
+    debug_print("😞 未找到连接的容器 💔")
+    return None
 
 def generate_evaporate_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    pressure: float,
-    temp: float,
-    time: float,
-    stir_speed: float
-) -> list[dict]:
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    pressure: float = 0.1,
+    temp: float = 60.0,
+    time: Union[str, float] = "180",     # 🔧 修改：支持字符串时间
+    stir_speed: float = 100.0,
+    solvent: str = "",
+    **kwargs
+) -> List[Dict[str, Any]]:
     """
-    Generate a protocol to evaporate a solution from a vessel.
+    生成蒸发操作的协议序列 - 支持单位和体积运算
     
-    :param G: Directed graph. Nodes are containers and pumps, edges are fluidic connections.
-    :param vessel: Vessel to clean.
-    :param solvent: Solvent to clean vessel with.
-    :param volume: Volume of solvent to clean vessel with.
-    :param temp: Temperature to heat vessel to while cleaning.
-    :param repeats: Number of cleaning cycles to perform.
-    :return: List of actions to clean vessel.
+    Args:
+        G: 设备图
+        vessel: 容器字典（从XDL传入）
+        pressure: 真空度 (bar)，默认0.1
+        temp: 加热温度 (°C)，默认60
+        time: 蒸发时间（支持 "3 min", "180", "0.5 h" 等）
+        stir_speed: 旋转速度 (RPM)，默认100
+        solvent: 溶剂名称（用于参数优化）
+        **kwargs: 其他参数（兼容性）
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
     """
     
-    # 生成泵操作的动作序列
-    pump_action_sequence = []
-    reactor_volume = 500.0
-    transfer_flowrate = flowrate = 2.5
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
     
-    # 开启冷凝器
-    pump_action_sequence.append({
-        "device_id": "rotavap_chiller",
-        "action_name": "set_temperature",
-        "action_kwargs": {
-            "command": "-40"
-        }
-    })
-    # TODO: 通过温度反馈改为 HeatChillToTemp，而非等待固定时间
-    pump_action_sequence.append({
+    debug_print("🌟" * 20)
+    debug_print("🌪️ 开始生成蒸发协议（支持单位和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  💨 pressure: {pressure} bar")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time} (类型: {type(time)})")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  🧪 solvent: '{solvent}'")
+    debug_print("🌟" * 20)
+    
+    # 🔧 新增：记录蒸发前的容器状态
+    debug_print("🔍 记录蒸发前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    debug_print(f"📊 蒸发前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # === 步骤1: 查找旋转蒸发仪设备 ===
+    debug_print("📍 步骤1: 查找旋转蒸发仪设备... 🔍")
+    
+    # 验证vessel参数
+    if not vessel_id:
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    # 查找旋转蒸发仪设备
+    rotavap_device = find_rotavap_device(G, vessel_id)
+    if not rotavap_device:
+        debug_print("💥 未找到旋转蒸发仪设备! 😭")
+        raise ValueError(f"未找到旋转蒸发仪设备。请检查组态图中是否包含 class 包含 'rotavap'、'rotary' 或 'evaporat' 的设备")
+    
+    debug_print(f"🎉 成功找到旋转蒸发仪: {rotavap_device} ✨")
+    
+    # === 步骤2: 确定目标容器 ===
+    debug_print("📍 步骤2: 确定目标容器... 🥽")
+    
+    target_vessel = vessel_id
+    
+    # 如果vessel就是旋转蒸发仪设备，查找连接的容器
+    if vessel_id == rotavap_device:
+        debug_print("🔄 vessel就是旋转蒸发仪，查找连接的容器...")
+        connected_vessel = find_connected_vessel(G, rotavap_device)
+        if connected_vessel:
+            target_vessel = connected_vessel
+            debug_print(f"✅ 使用连接的容器: {target_vessel} 🥽✨")
+        else:
+            debug_print(f"⚠️ 未找到连接的容器，使用设备本身: {rotavap_device} 🔧")
+            target_vessel = rotavap_device
+    elif vessel_id in G.nodes() and G.nodes[vessel_id].get('type') == 'container':
+        debug_print(f"✅ 使用指定的容器: {vessel_id} 🥽✨")
+        target_vessel = vessel_id
+    else:
+        debug_print(f"⚠️ 容器 '{vessel_id}' 不存在或类型不正确，使用旋转蒸发仪设备: {rotavap_device} 🔧")
+        target_vessel = rotavap_device
+    
+    # === 🔧 新增：步骤3：单位解析处理 ===
+    debug_print("📍 步骤3: 单位解析处理... ⚡")
+    
+    # 解析时间
+    final_time = parse_time_input(time)
+    debug_print(f"🎯 时间解析完成: {time} → {final_time}s ({final_time/60:.1f}分钟) ⏰✨")
+    
+    # === 步骤4: 参数验证和修正 ===
+    debug_print("📍 步骤4: 参数验证和修正... 🔧")
+    
+    # 修正参数范围
+    if pressure <= 0 or pressure > 1.0:
+        debug_print(f"⚠️ 真空度 {pressure} bar 超出范围，修正为 0.1 bar 💨")
+        pressure = 0.1
+    else:
+        debug_print(f"✅ 真空度 {pressure} bar 在正常范围内 💨")
+    
+    if temp < 10.0 or temp > 200.0:
+        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 60°C 🌡️")
+        temp = 60.0
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内 🌡️")
+    
+    if final_time <= 0:
+        debug_print(f"⚠️ 时间 {final_time}s 无效，修正为 180s (3分钟) ⏰")
+        final_time = 180.0
+    else:
+        debug_print(f"✅ 时间 {final_time}s ({final_time/60:.1f}分钟) 有效 ⏰")
+    
+    if stir_speed < 10.0 or stir_speed > 300.0:
+        debug_print(f"⚠️ 旋转速度 {stir_speed} RPM 超出范围，修正为 100 RPM 🌪️")
+        stir_speed = 100.0
+    else:
+        debug_print(f"✅ 旋转速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
+    # 根据溶剂优化参数
+    if solvent:
+        debug_print(f"🧪 根据溶剂 '{solvent}' 优化参数... 🔬")
+        solvent_lower = solvent.lower()
+        
+        if any(s in solvent_lower for s in ['water', 'aqueous', 'h2o']):
+            temp = max(temp, 80.0)
+            pressure = max(pressure, 0.2)
+            debug_print("💧 水系溶剂：提高温度和真空度 🌡️💨")
+        elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+            temp = min(temp, 50.0)
+            pressure = min(pressure, 0.05)
+            debug_print("🍺 易挥发溶剂：降低温度和真空度 🌡️💨")
+        elif any(s in solvent_lower for s in ['dmso', 'dmi', 'toluene']):
+            temp = max(temp, 100.0)
+            pressure = min(pressure, 0.01)
+            debug_print("🔥 高沸点溶剂：提高温度，降低真空度 🌡️💨")
+        else:
+            debug_print("🧪 通用溶剂，使用标准参数 ✨")
+    else:
+        debug_print("🤷‍♀️ 未指定溶剂，使用默认参数 ✨")
+    
+    debug_print(f"🎯 最终参数: pressure={pressure} bar 💨, temp={temp}°C 🌡️, time={final_time}s ⏰, stir_speed={stir_speed} RPM 🌪️")
+    
+    # === 🔧 新增：步骤5：蒸发体积计算 ===
+    debug_print("📍 步骤5: 蒸发体积计算... 📊")
+    
+    # 根据温度、真空度、时间和溶剂类型估算蒸发量
+    evaporation_volume = 0.0
+    if original_liquid_volume > 0:
+        # 基础蒸发速率（mL/min）
+        base_evap_rate = 0.5  # 基础速率
+        
+        # 温度系数（高温蒸发更快）
+        temp_factor = 1.0 + (temp - 25.0) / 100.0
+        
+        # 真空系数（真空度越高蒸发越快）
+        vacuum_factor = 1.0 + (1.0 - pressure) * 2.0
+        
+        # 溶剂系数
+        solvent_factor = 1.0
+        if solvent:
+            solvent_lower = solvent.lower()
+            if any(s in solvent_lower for s in ['water', 'h2o']):
+                solvent_factor = 0.8  # 水蒸发较慢
+            elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+                solvent_factor = 1.5  # 易挥发溶剂蒸发快
+            elif any(s in solvent_lower for s in ['dmso', 'dmi']):
+                solvent_factor = 0.3  # 高沸点溶剂蒸发慢
+        
+        # 计算总蒸发量
+        total_evap_rate = base_evap_rate * temp_factor * vacuum_factor * solvent_factor
+        evaporation_volume = min(
+            original_liquid_volume * 0.95,  # 最多蒸发95%
+            total_evap_rate * (final_time / 60.0)  # 时间相关的蒸发量
+        )
+        
+        debug_print(f"📊 蒸发量计算:")
+        debug_print(f"  - 基础蒸发速率: {base_evap_rate} mL/min")
+        debug_print(f"  - 温度系数: {temp_factor:.2f} (基于 {temp}°C)")
+        debug_print(f"  - 真空系数: {vacuum_factor:.2f} (基于 {pressure} bar)")
+        debug_print(f"  - 溶剂系数: {solvent_factor:.2f} ({solvent or '通用'})")
+        debug_print(f"  - 总蒸发速率: {total_evap_rate:.2f} mL/min")
+        debug_print(f"  - 预计蒸发量: {evaporation_volume:.2f}mL ({evaporation_volume/original_liquid_volume*100:.1f}%)")
+    
+    # === 步骤6: 生成动作序列 ===
+    debug_print("📍 步骤6: 生成动作序列... 🎬")
+    
+    action_sequence = []
+    
+    # 1. 等待稳定
+    debug_print("  🔄 动作1: 添加初始等待稳定... ⏳")
+    action_sequence.append({
         "action_name": "wait",
-        "action_kwargs": {
-            "time": 1800
-        }
+        "action_kwargs": {"time": 10}
     })
+    debug_print("  ✅ 初始等待动作已添加 ⏳✨")
     
-    # 开启旋蒸真空泵、旋转，在液体转移后运行time时间
-    pump_action_sequence.append({
-        "device_id": "rotavap_controller",
-        "action_name": "set_pump_time",
-        "action_kwargs": {
-            "command": str(time + reactor_volume / flowrate * 3)
-        }
-    })
-    pump_action_sequence.append({
-        "device_id": "rotavap_controller",
-        "action_name": "set_pump_time",
-        "action_kwargs": {
-            "command": str(time + reactor_volume / flowrate * 3)
-        }
-    })
+    # 2. 执行蒸发
+    debug_print(f"  🌪️ 动作2: 执行蒸发操作...")
+    debug_print(f"    🔧 设备: {rotavap_device}")
+    debug_print(f"    🥽 容器: {target_vessel}")
+    debug_print(f"    💨 真空度: {pressure} bar")
+    debug_print(f"    🌡️ 温度: {temp}°C")
+    debug_print(f"    ⏰ 时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print(f"    🌪️ 旋转速度: {stir_speed} RPM")
     
-    # 液体转入旋转蒸发器
-    pump_action_sequence.append({
-        "device_id": "", 
-        "action_name": "PumpTransferProtocol",
+    evaporate_action = {
+        "device_id": rotavap_device,
+        "action_name": "evaporate",
         "action_kwargs": {
-            "from_vessel": vessel,
-            "to_vessel": "rotavap",
-            "volume": reactor_volume,
-            "time": reactor_volume / flowrate,
-            # "transfer_flowrate": transfer_flowrate,
+            "vessel": {"id": target_vessel},
+            "pressure": float(pressure),
+            "temp": float(temp),
+            "time": float(final_time),  # 🔧 强制转换为float类型
+            "stir_speed": float(stir_speed),
+            "solvent": str(solvent)
         }
-    })
+    }
+    action_sequence.append(evaporate_action)
+    debug_print("  ✅ 蒸发动作已添加 🌪️✨")
     
-    pump_action_sequence.append({
+    # 🔧 新增：蒸发过程中的体积变化
+    debug_print("  🔧 更新容器体积 - 蒸发过程...")
+    if evaporation_volume > 0:
+        new_volume = max(0.0, original_liquid_volume - evaporation_volume)
+        
+        # 更新vessel字典中的体积
+        if "data" in vessel and "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            elif isinstance(current_volume, (int, float)):
+                vessel["data"]["liquid_volume"] = new_volume
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        
+        # 🔧 同时更新图中的容器数据
+        if vessel_id in G.nodes():
+            if 'data' not in G.nodes[vessel_id]:
+                G.nodes[vessel_id]['data'] = {}
+            
+            vessel_node_data = G.nodes[vessel_id]['data']
+            current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+            
+            if isinstance(current_node_volume, list):
+                if len(current_node_volume) > 0:
+                    G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+                else:
+                    G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+        
+        debug_print(f"  📊 蒸发体积变化: {original_liquid_volume:.2f}mL → {new_volume:.2f}mL (-{evaporation_volume:.2f}mL)")
+    
+    # 3. 蒸发后等待
+    debug_print("  🔄 动作3: 添加蒸发后等待... ⏳")
+    action_sequence.append({
         "action_name": "wait",
-        "action_kwargs": {
-            "time": time
-        }
+        "action_kwargs": {"time": 10}
     })
-    return pump_action_sequence
+    debug_print("  ✅ 蒸发后等待动作已添加 ⏳✨")
+    
+    # 🔧 新增：蒸发完成后的状态报告
+    final_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_liquid_volume = current_volume
+    
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 蒸发协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🌪️ 旋转蒸发仪: {rotavap_device} 🔧")
+    debug_print(f"🥽 目标容器: {target_vessel} 🧪")
+    debug_print(f"⚙️ 蒸发参数: {pressure} bar 💨, {temp}°C 🌡️, {final_time}s ⏰, {stir_speed} RPM 🌪️")
+    debug_print(f"⏱️ 预计总时间: {(final_time + 20)/60:.1f} 分钟 ⌛")
+    debug_print(f"📊 体积变化:")
+    debug_print(f"  - 蒸发前: {original_liquid_volume:.2f}mL")
+    debug_print(f"  - 蒸发后: {final_liquid_volume:.2f}mL") 
+    debug_print(f"  - 蒸发量: {evaporation_volume:.2f}mL ({evaporation_volume/max(original_liquid_volume, 0.01)*100:.1f}%)")
+    debug_print("🎊" * 20)
+    
+    return action_sequence

unilabos/compile/filter_protocol.py

@@ -1,70 +1,366 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 import networkx as nx
+import logging
+from .utils.vessel_parser import get_vessel
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[FILTER] {message}")
+
+def find_filter_device(G: nx.DiGraph) -> str:
+    """查找过滤器设备"""
+    debug_print("🔍 查找过滤器设备... 🌊")
+    
+    # 查找过滤器设备
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'filter' in node_class.lower() or 'filter' in node.lower():
+            debug_print(f"🎉 找到过滤器设备: {node} ✨")
+            return node
+    
+    # 如果没找到，寻找可能的过滤器名称
+    debug_print("🔎 在预定义名称中搜索过滤器... 📋")
+    possible_names = ["filter", "filter_1", "virtual_filter", "filtration_unit"]
+    for name in possible_names:
+        if name in G.nodes():
+            debug_print(f"🎉 找到过滤器设备: {name} ✨")
+            return name
+    
+    debug_print("😭 未找到过滤器设备 💔")
+    raise ValueError("未找到过滤器设备")
+
+def validate_vessel(G: nx.DiGraph, vessel: str, vessel_type: str = "容器") -> None:
+    """验证容器是否存在"""
+    debug_print(f"🔍 验证{vessel_type}: '{vessel}' 🧪")
+    
+    if not vessel:
+        debug_print(f"❌ {vessel_type}不能为空! 😱")
+        raise ValueError(f"{vessel_type}不能为空")
+    
+    if vessel not in G.nodes():
+        debug_print(f"❌ {vessel_type} '{vessel}' 不存在于系统中! 😞")
+        raise ValueError(f"{vessel_type} '{vessel}' 不存在于系统中")
+    
+    debug_print(f"✅ {vessel_type} '{vessel}' 验证通过 🎯")
 
 def generate_filter_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    filtrate_vessel: str = "",
-    stir: bool = False,
-    stir_speed: float = 300.0,
-    temp: float = 25.0,
-    continue_heatchill: bool = False,
-    volume: float = 0.0
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    filtrate_vessel: dict = {"id": "waste"},
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成过滤操作的协议序列
+    生成过滤操作的协议序列 - 支持体积运算
     
     Args:
-        G: 有向图，节点为设备和容器
-        vessel: 过滤容器
-        filtrate_vessel: 滤液容器（可选）
-        stir: 是否搅拌
-        stir_speed: 搅拌速度（可选）
-        temp: 温度（可选，摄氏度）
-        continue_heatchill: 是否继续加热冷却
-        volume: 过滤体积（可选）
+        G: 设备图
+        vessel: 过滤容器字典（必需）- 包含需要过滤的混合物
+        filtrate_vessel: 滤液容器名称（可选）- 如果提供则收集滤液
+        **kwargs: 其他参数（兼容性）
     
     Returns:
         List[Dict[str, Any]]: 过滤操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到过滤设备时抛出异常
-    
-    Examples:
-        filter_protocol = generate_filter_protocol(G, "reactor", "filtrate_vessel", stir=True, volume=100.0)
     """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    filtrate_vessel_id, filtrate_vessel_data = get_vessel(filtrate_vessel)
+    
+    debug_print("🌊" * 20)
+    debug_print("🚀 开始生成过滤协议（支持体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🧪 filtrate_vessel: {filtrate_vessel}")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("🌊" * 20)
+    
     action_sequence = []
     
-    # 查找过滤设备
-    filter_nodes = [node for node in G.nodes() 
-                   if G.nodes[node].get('class') == 'virtual_filter']
+    # 🔧 新增：记录过滤前的容器状态
+    debug_print("🔍 记录过滤前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    debug_print(f"📊 过滤前液体体积: {original_liquid_volume:.2f}mL")
     
-    if not filter_nodes:
-        raise ValueError("没有找到可用的过滤设备")
+    # === 参数验证 ===
+    debug_print("📍 步骤1: 参数验证... 🔧")
     
-    # 使用第一个可用的过滤器
-    filter_id = filter_nodes[0]
+    # 验证必需参数
+    debug_print("  🔍 验证必需参数...")
+    validate_vessel(G, vessel_id, "过滤容器")  # 🔧 使用 vessel_id
+    debug_print("  ✅ 必需参数验证完成 🎯")
     
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"过滤容器 {vessel} 不存在于图中")
+    # 验证可选参数
+    debug_print("  🔍 验证可选参数...")
+    if filtrate_vessel:
+        validate_vessel(G, filtrate_vessel_id, "滤液容器")
+        debug_print("  🌊 模式: 过滤并收集滤液 💧")
+    else:
+        debug_print("  🧱 模式: 过滤并收集固体 🔬")
+    debug_print("  ✅ 可选参数验证完成 🎯")
     
-    if filtrate_vessel and filtrate_vessel not in G.nodes():
-        raise ValueError(f"滤液容器 {filtrate_vessel} 不存在于图中")
+    # === 查找设备 ===
+    debug_print("📍 步骤2: 查找设备... 🔍")
     
-    # 执行过滤操作
+    try:
+        debug_print("  🔎 搜索过滤器设备...")
+        filter_device = find_filter_device(G)
+        debug_print(f"  🎉 使用过滤器设备: {filter_device} 🌊✨")
+        
+    except Exception as e:
+        debug_print(f"  ❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"设备查找失败: {str(e)}")
+    
+    # 🔧 新增：过滤效率和体积分配估算
+    debug_print("📍 步骤2.5: 过滤体积分配估算... 📊")
+    
+    # 估算过滤分离比例（基于经验数据）
+    solid_ratio = 0.1  # 假设10%是固体（保留在过滤器上）
+    liquid_ratio = 0.9  # 假设90%是液体（通过过滤器）
+    volume_loss_ratio = 0.05  # 假设5%体积损失（残留在过滤器等）
+    
+    # 从kwargs中获取过滤参数进行优化
+    if "solid_content" in kwargs:
+        try:
+            solid_ratio = float(kwargs["solid_content"])
+            liquid_ratio = 1.0 - solid_ratio
+            debug_print(f"📋 使用指定的固体含量: {solid_ratio*100:.1f}%")
+        except:
+            debug_print("⚠️ 固体含量参数无效，使用默认值")
+    
+    if original_liquid_volume > 0:
+        expected_filtrate_volume = original_liquid_volume * liquid_ratio * (1.0 - volume_loss_ratio)
+        expected_solid_volume = original_liquid_volume * solid_ratio
+        volume_loss = original_liquid_volume * volume_loss_ratio
+        
+        debug_print(f"📊 过滤体积分配估算:")
+        debug_print(f"  - 原始体积: {original_liquid_volume:.2f}mL")
+        debug_print(f"  - 预计滤液体积: {expected_filtrate_volume:.2f}mL ({liquid_ratio*100:.1f}%)")
+        debug_print(f"  - 预计固体体积: {expected_solid_volume:.2f}mL ({solid_ratio*100:.1f}%)")
+        debug_print(f"  - 预计损失体积: {volume_loss:.2f}mL ({volume_loss_ratio*100:.1f}%)")
+    
+    # === 转移到过滤器（如果需要）===
+    debug_print("📍 步骤3: 转移到过滤器... 🚚")
+    
+    if vessel_id != filter_device:  # 🔧 使用 vessel_id
+        debug_print(f"  🚛 需要转移: {vessel_id} → {filter_device} 📦")
+        
+        try:
+            debug_print("  🔄 开始执行转移操作...")
+            # 使用pump protocol转移液体到过滤器
+            transfer_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel={"id": vessel_id},  # 🔧 使用 vessel_id
+                to_vessel={"id": filter_device},
+                volume=0.0,  # 转移所有液体
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            
+            if transfer_actions:
+                action_sequence.extend(transfer_actions)
+                debug_print(f"  ✅ 添加了 {len(transfer_actions)} 个转移动作 🚚✨")
+                
+                # 🔧 新增：转移后更新容器体积
+                debug_print("  🔧 更新转移后的容器体积...")
+                
+                # 原容器体积变为0（所有液体已转移）
+                if "data" in vessel and "liquid_volume" in vessel["data"]:
+                    current_volume = vessel["data"]["liquid_volume"]
+                    if isinstance(current_volume, list):
+                        vessel["data"]["liquid_volume"] = [0.0] if len(current_volume) > 0 else [0.0]
+                    else:
+                        vessel["data"]["liquid_volume"] = 0.0
+                
+                # 同时更新图中的容器数据
+                if vessel_id in G.nodes():
+                    if 'data' not in G.nodes[vessel_id]:
+                        G.nodes[vessel_id]['data'] = {}
+                    G.nodes[vessel_id]['data']['liquid_volume'] = 0.0
+                
+                debug_print(f"  📊 转移完成，{vessel_id} 体积更新为 0.0mL")
+                
+            else:
+                debug_print("  ⚠️ 转移协议返回空序列 🤔")
+                
+        except Exception as e:
+            debug_print(f"  ❌ 转移失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能是直接连接的过滤器 🤞")
+    else:
+        debug_print("  ✅ 过滤容器就是过滤器，无需转移 🎯")
+    
+    # === 执行过滤操作 ===
+    debug_print("📍 步骤4: 执行过滤操作... 🌊")
+    
+    # 构建过滤动作参数
+    debug_print("  ⚙️ 构建过滤参数...")
+    filter_kwargs = {
+        "vessel": {"id": filter_device},  # 过滤器设备
+        "filtrate_vessel": {"id": filtrate_vessel_id},  # 滤液容器（可能为空）
+        "stir": kwargs.get("stir", False),
+        "stir_speed": kwargs.get("stir_speed", 0.0),
+        "temp": kwargs.get("temp", 25.0),
+        "continue_heatchill": kwargs.get("continue_heatchill", False),
+        "volume": kwargs.get("volume", 0.0)  # 0表示过滤所有
+    }
+    
+    debug_print(f"  📋 过滤参数: {filter_kwargs}")
+    debug_print("  🌊 开始过滤操作...")
+    
+    # 过滤动作
+    filter_action = {
+        "device_id": filter_device,
+        "action_name": "filter",
+        "action_kwargs": filter_kwargs
+    }
+    action_sequence.append(filter_action)
+    debug_print("  ✅ 过滤动作已添加 🌊✨")
+    
+    # 过滤后等待
+    debug_print("  ⏳ 添加过滤后等待...")
     action_sequence.append({
-        "device_id": filter_id,
-        "action_name": "filter_sample",
-        "action_kwargs": {
-            "vessel": vessel,
-            "filtrate_vessel": filtrate_vessel,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "temp": temp,
-            "continue_heatchill": continue_heatchill,
-            "volume": volume
-        }
+        "action_name": "wait",
+        "action_kwargs": {"time": 10.0}
     })
+    debug_print("  ✅ 过滤后等待动作已添加 ⏰✨")
+    
+    # === 收集滤液（如果需要）===
+    debug_print("📍 步骤5: 收集滤液... 💧")
+    
+    if filtrate_vessel_id and filtrate_vessel_id not in G.neighbors(filter_device):
+        debug_print(f"  🧪 收集滤液: {filter_device} → {filtrate_vessel_id} 💧")
+        
+        try:
+            debug_print("  🔄 开始执行收集操作...")
+            # 使用pump protocol收集滤液
+            collect_actions = generate_pump_protocol_with_rinsing(
+                G=G,
+                from_vessel=filter_device,
+                to_vessel=filtrate_vessel,
+                volume=0.0,  # 收集所有滤液
+                amount="",
+                time=0.0,
+                viscous=False,
+                rinsing_solvent="",
+                rinsing_volume=0.0,
+                rinsing_repeats=0,
+                solid=False,
+                flowrate=2.0,
+                transfer_flowrate=2.0
+            )
+            
+            if collect_actions:
+                action_sequence.extend(collect_actions)
+                debug_print(f"  ✅ 添加了 {len(collect_actions)} 个收集动作 🧪✨")
+                
+                # 🔧 新增：收集滤液后的体积更新
+                debug_print("  🔧 更新滤液容器体积...")
+                
+                # 更新filtrate_vessel在图中的体积（如果它是节点）
+                if filtrate_vessel_id in G.nodes():
+                    if 'data' not in G.nodes[filtrate_vessel_id]:
+                        G.nodes[filtrate_vessel_id]['data'] = {}
+                    
+                    current_filtrate_volume = G.nodes[filtrate_vessel_id]['data'].get('liquid_volume', 0.0)
+                    if isinstance(current_filtrate_volume, list):
+                        if len(current_filtrate_volume) > 0:
+                            G.nodes[filtrate_vessel_id]['data']['liquid_volume'][0] += expected_filtrate_volume
+                        else:
+                            G.nodes[filtrate_vessel_id]['data']['liquid_volume'] = [expected_filtrate_volume]
+                    else:
+                        G.nodes[filtrate_vessel_id]['data']['liquid_volume'] = current_filtrate_volume + expected_filtrate_volume
+                    
+                    debug_print(f"  📊 滤液容器 {filtrate_vessel_id} 体积增加 {expected_filtrate_volume:.2f}mL")
+                
+            else:
+                debug_print("  ⚠️ 收集协议返回空序列 🤔")
+                
+        except Exception as e:
+            debug_print(f"  ❌ 收集滤液失败: {str(e)} 😞")
+            debug_print("  🔄 继续执行，可能滤液直接流入指定容器 🤞")
+    else:
+        debug_print("  🧱 未指定滤液容器，固体保留在过滤器中 🔬")
+    
+    # 🔧 新增：过滤完成后的容器状态更新
+    debug_print("📍 步骤5.5: 过滤完成后状态更新... 📊")
+    
+    if vessel_id == filter_device:
+        # 如果过滤容器就是过滤器，需要更新其体积状态
+        if original_liquid_volume > 0:
+            if filtrate_vessel:
+                # 收集滤液模式：过滤器中主要保留固体
+                remaining_volume = expected_solid_volume
+                debug_print(f"  🧱 过滤器中保留固体: {remaining_volume:.2f}mL")
+            else:
+                # 保留固体模式：过滤器中保留所有物质
+                remaining_volume = original_liquid_volume * (1.0 - volume_loss_ratio)
+                debug_print(f"  🔬 过滤器中保留所有物质: {remaining_volume:.2f}mL")
+            
+            # 更新vessel字典中的体积
+            if "data" in vessel and "liquid_volume" in vessel["data"]:
+                current_volume = vessel["data"]["liquid_volume"]
+                if isinstance(current_volume, list):
+                    vessel["data"]["liquid_volume"] = [remaining_volume] if len(current_volume) > 0 else [remaining_volume]
+                else:
+                    vessel["data"]["liquid_volume"] = remaining_volume
+            
+            # 同时更新图中的容器数据
+            if vessel_id in G.nodes():
+                if 'data' not in G.nodes[vessel_id]:
+                    G.nodes[vessel_id]['data'] = {}
+                G.nodes[vessel_id]['data']['liquid_volume'] = remaining_volume
+            
+            debug_print(f"  📊 过滤器 {vessel_id} 体积更新为: {remaining_volume:.2f}mL")
+    
+    # === 最终等待 ===
+    debug_print("📍 步骤6: 最终等待... ⏰")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {"time": 5.0}
+    })
+    debug_print("  ✅ 最终等待动作已添加 ⏰✨")
+    
+    # 🔧 新增：过滤完成后的状态报告
+    final_vessel_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            final_vessel_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            final_vessel_volume = current_volume
+    
+    # === 总结 ===
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 过滤协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个 📝")
+    debug_print(f"🥽 过滤容器: {vessel_id} 🧪")
+    debug_print(f"🌊 过滤器设备: {filter_device} 🔧")
+    debug_print(f"💧 滤液容器: {filtrate_vessel_id or '无（保留固体）'} 🧱")
+    debug_print(f"⏱️ 预计总时间: {(len(action_sequence) * 5):.0f} 秒 ⌛")
+    if original_liquid_volume > 0:
+        debug_print(f"📊 体积变化统计:")
+        debug_print(f"  - 过滤前体积: {original_liquid_volume:.2f}mL")
+        debug_print(f"  - 过滤后容器体积: {final_vessel_volume:.2f}mL")
+        if filtrate_vessel:
+            debug_print(f"  - 预计滤液体积: {expected_filtrate_volume:.2f}mL")
+        debug_print(f"  - 预计损失体积: {volume_loss:.2f}mL")
+    debug_print("🎊" * 20)
     
     return action_sequence

unilabos/compile/filter_through_protocol.py

@@ -1,5 +1,72 @@
 from typing import List, Dict, Any
 import networkx as nx
+from .pump_protocol import generate_pump_protocol
+
+
+def get_vessel_liquid_volume(G: nx.DiGraph, vessel: str) -> float:
+    """获取容器中的液体体积"""
+    if vessel not in G.nodes():
+        return 0.0
+    
+    vessel_data = G.nodes[vessel].get('data', {})
+    liquids = vessel_data.get('liquid', [])
+    
+    total_volume = 0.0
+    for liquid in liquids:
+        if isinstance(liquid, dict) and 'liquid_volume' in liquid:
+            total_volume += liquid['liquid_volume']
+    
+    return total_volume
+
+
+def find_filter_through_vessel(G: nx.DiGraph, filter_through: str) -> str:
+    """查找过滤介质容器"""
+    # 直接使用 filter_through 参数作为容器名称
+    if filter_through in G.nodes():
+        return filter_through
+    
+    # 尝试常见的过滤介质容器命名
+    possible_names = [
+        f"filter_{filter_through}",
+        f"{filter_through}_filter",
+        f"column_{filter_through}",
+        f"{filter_through}_column",
+        "filter_through_vessel",
+        "column_vessel",
+        "chromatography_column",
+        "filter_column"
+    ]
+    
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            return vessel_name
+    
+    raise ValueError(f"未找到过滤介质容器 '{filter_through}'。尝试了以下名称: {[filter_through] + possible_names}")
+
+
+def find_eluting_solvent_vessel(G: nx.DiGraph, eluting_solvent: str) -> str:
+    """查找洗脱溶剂容器"""
+    if not eluting_solvent:
+        return ""
+    
+    # 按照命名规则查找溶剂瓶
+    solvent_vessel_id = f"flask_{eluting_solvent}"
+    
+    if solvent_vessel_id in G.nodes():
+        return solvent_vessel_id
+    
+    # 如果直接匹配失败，尝试模糊匹配
+    for node in G.nodes():
+        if node.startswith('flask_') and eluting_solvent.lower() in node.lower():
+            return node
+    
+    # 如果还是找不到，列出所有可用的溶剂瓶
+    available_flasks = [node for node in G.nodes() 
+                       if node.startswith('flask_') 
+                       and G.nodes[node].get('type') == 'container']
+    
+    raise ValueError(f"找不到洗脱溶剂 '{eluting_solvent}' 对应的溶剂瓶。可用溶剂瓶: {available_flasks}")
+
 
 def generate_filter_through_protocol(
     G: nx.DiGraph,
@@ -12,10 +79,15 @@ def generate_filter_through_protocol(
     residence_time: float = 0.0
 ) -> List[Dict[str, Any]]:
     """
-    生成通过过滤介质过滤的协议序列
+    生成通过过滤介质过滤的协议序列，复用 pump_protocol 的成熟算法
+    
+    过滤流程：
+    1. 液体转移：将样品从源容器转移到过滤介质
+    2. 重力过滤：液体通过过滤介质自动流到目标容器
+    3. 洗脱操作：将洗脱溶剂通过过滤介质洗脱目标物质
     
     Args:
-        G: 有向图，节点为设备和容器
+        G: 有向图，节点为设备和容器，边为流体管道
         from_vessel: 源容器的名称，即物质起始所在的容器
         to_vessel: 目标容器的名称，物质过滤后要到达的容器
         filter_through: 过滤时所通过的介质，如滤纸、柱子等
@@ -28,123 +100,288 @@ def generate_filter_through_protocol(
         List[Dict[str, Any]]: 过滤操作的动作序列
     
     Raises:
-        ValueError: 当找不到必要的设备时抛出异常
+        ValueError: 当找不到必要的设备或容器时
     
     Examples:
-        filter_through_protocol = generate_filter_through_protocol(
-            G, "reactor", "collection_flask", "celite", "ethanol", 50.0, 2, 60.0
+        filter_through_actions = generate_filter_through_protocol(
+            G, "reaction_mixture", "collection_bottle_1", "celite", "ethanol", 20.0, 2, 30.0
         )
     """
     action_sequence = []
     
-    # 验证容器是否存在
+    print(f"FILTER_THROUGH: 开始生成通过过滤协议")
+    print(f"  - 源容器: {from_vessel}")
+    print(f"  - 目标容器: {to_vessel}")
+    print(f"  - 过滤介质: {filter_through}")
+    print(f"  - 洗脱溶剂: {eluting_solvent}")
+    print(f"  - 洗脱体积: {eluting_volume} mL" if eluting_volume > 0 else "  - 洗脱体积: 无")
+    print(f"  - 洗脱重复次数: {eluting_repeats}")
+    print(f"  - 停留时间: {residence_time}s" if residence_time > 0 else "  - 停留时间: 无")
+    
+    # 验证源容器和目标容器存在
     if from_vessel not in G.nodes():
-        raise ValueError(f"源容器 {from_vessel} 不存在于图中")
+        raise ValueError(f"源容器 '{from_vessel}' 不存在于系统中")
     
     if to_vessel not in G.nodes():
-        raise ValueError(f"目标容器 {to_vessel} 不存在于图中")
+        raise ValueError(f"目标容器 '{to_vessel}' 不存在于系统中")
     
-    # 查找转移泵设备（用于液体转移）
-    pump_nodes = [node for node in G.nodes() 
-                  if G.nodes[node].get('class') == 'virtual_transfer_pump']
+    # 获取源容器中的液体体积
+    source_volume = get_vessel_liquid_volume(G, from_vessel)
+    print(f"FILTER_THROUGH: 源容器 {from_vessel} 中有 {source_volume} mL 液体")
     
-    if not pump_nodes:
-        raise ValueError("没有找到可用的转移泵设备")
+    # 查找过滤介质容器
+    try:
+        filter_through_vessel = find_filter_through_vessel(G, filter_through)
+        print(f"FILTER_THROUGH: 找到过滤介质容器: {filter_through_vessel}")
+    except ValueError as e:
+        raise ValueError(f"无法找到过滤介质容器: {str(e)}")
     
-    pump_id = pump_nodes[0]
+    # 查找洗脱溶剂容器（如果需要）
+    eluting_vessel = ""
+    if eluting_solvent and eluting_volume > 0 and eluting_repeats > 0:
+        try:
+            eluting_vessel = find_eluting_solvent_vessel(G, eluting_solvent)
+            print(f"FILTER_THROUGH: 找到洗脱溶剂容器: {eluting_vessel}")
+        except ValueError as e:
+            raise ValueError(f"无法找到洗脱溶剂容器: {str(e)}")
     
-    # 查找过滤设备（可选，如果有专门的过滤设备）
-    filter_nodes = [node for node in G.nodes() 
-                   if G.nodes[node].get('class') == 'virtual_filter']
+    # === 第一步：将样品从源容器转移到过滤介质 ===
+    transfer_volume = source_volume if source_volume > 0 else 100.0  # 默认100mL
+    print(f"FILTER_THROUGH: 将 {transfer_volume} mL 样品从 {from_vessel} 转移到 {filter_through_vessel}")
     
-    filter_id = filter_nodes[0] if filter_nodes else None
+    try:
+        # 使用成熟的 pump_protocol 算法进行液体转移
+        sample_transfer_actions = generate_pump_protocol(
+            G=G,
+            from_vessel=from_vessel,
+            to_vessel=filter_through_vessel,
+            volume=transfer_volume,
+            flowrate=0.8,  # 较慢的流速，避免冲击过滤介质
+            transfer_flowrate=1.2
+        )
+        action_sequence.extend(sample_transfer_actions)
+    except Exception as e:
+        raise ValueError(f"无法将样品转移到过滤介质: {str(e)}")
     
-    # 查找洗脱溶剂容器（如果需要洗脱）
-    eluting_vessel = None
-    if eluting_solvent and eluting_volume > 0:
-        eluting_vessel = f"flask_{eluting_solvent}"
-        if eluting_vessel not in G.nodes():
-            # 查找可用的溶剂容器
-            available_vessels = [node for node in G.nodes() 
-                               if node.startswith('flask_') and 
-                               G.nodes[node].get('type') == 'container']
-            if available_vessels:
-                eluting_vessel = available_vessels[0]
-            else:
-                raise ValueError(f"没有找到洗脱溶剂容器 {eluting_solvent}")
-    
-    # 步骤1：将样品从源容器转移到过滤装置（模拟通过过滤介质）
-    # 这里我们将过滤过程分解为多个转移步骤来模拟通过介质的过程
-    
-    # 首先转移样品（模拟样品通过过滤介质）
-    action_sequence.append({
-        "device_id": pump_id,
-        "action_name": "transfer",
-        "action_kwargs": {
-            "from_vessel": from_vessel,
-            "to_vessel": to_vessel,
-            "volume": 0.0,  # 转移所有液体，体积由系统确定
-            "amount": f"通过 {filter_through} 过滤",
-            "time": residence_time if residence_time > 0 else 0.0,
-            "viscous": False,
-            "rinsing_solvent": "",
-            "rinsing_volume": 0.0,
-            "rinsing_repeats": 0,
-            "solid": True  # 通过过滤介质可能涉及固体分离
-        }
-    })
-    
-    # 步骤2：如果有专门的过滤设备，使用过滤设备处理
-    if filter_id:
+    # === 第二步：等待样品通过过滤介质（停留时间） ===
+    if residence_time > 0:
+        print(f"FILTER_THROUGH: 等待样品在过滤介质中停留 {residence_time}s")
         action_sequence.append({
-            "device_id": filter_id,
-            "action_name": "filter_sample",
-            "action_kwargs": {
-                "vessel": to_vessel,
-                "filtrate_vessel": to_vessel,
-                "stir": False,
-                "stir_speed": 0.0,
-                "temp": 25.0,
-                "continue_heatchill": False,
-                "volume": 0.0
-            }
+            "action_name": "wait",
+            "action_kwargs": {"time": residence_time}
+        })
+    else:
+        # 即使没有指定停留时间，也等待一段时间让液体通过
+        default_wait_time = max(10, transfer_volume / 10)  # 根据体积估算等待时间
+        print(f"FILTER_THROUGH: 等待样品通过过滤介质 {default_wait_time}s")
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {"time": default_wait_time}
         })
     
-    # 步骤3：洗脱操作（如果指定了洗脱溶剂和重复次数）
+    # === 第三步：洗脱操作（如果指定了洗脱参数） ===
     if eluting_solvent and eluting_volume > 0 and eluting_repeats > 0 and eluting_vessel:
-        for repeat in range(eluting_repeats):
-            # 添加洗脱溶剂
+        print(f"FILTER_THROUGH: 开始洗脱操作 - {eluting_repeats} 次，每次 {eluting_volume} mL {eluting_solvent}")
+        
+        for repeat_idx in range(eluting_repeats):
+            print(f"FILTER_THROUGH: 第 {repeat_idx + 1}/{eluting_repeats} 次洗脱")
+            
+            try:
+                # 将洗脱溶剂转移到过滤介质
+                eluting_transfer_actions = generate_pump_protocol(
+                    G=G,
+                    from_vessel=eluting_vessel,
+                    to_vessel=filter_through_vessel,
+                    volume=eluting_volume,
+                    flowrate=0.6,  # 洗脱用更慢的流速
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(eluting_transfer_actions)
+            except Exception as e:
+                raise ValueError(f"第 {repeat_idx + 1} 次洗脱转移失败: {str(e)}")
+            
+            # 等待洗脱溶剂通过过滤介质
+            eluting_wait_time = max(30, eluting_volume / 5)  # 根据洗脱体积估算等待时间
+            print(f"FILTER_THROUGH: 等待第 {repeat_idx + 1} 次洗脱液通过 {eluting_wait_time}s")
             action_sequence.append({
-                "device_id": pump_id,
-                "action_name": "transfer",
-                "action_kwargs": {
-                    "from_vessel": eluting_vessel,
-                    "to_vessel": to_vessel,
-                    "volume": eluting_volume,
-                    "amount": f"洗脱溶剂 {eluting_solvent} - 第 {repeat + 1} 次",
-                    "time": 0.0,
-                    "viscous": False,
-                    "rinsing_solvent": "",
-                    "rinsing_volume": 0.0,
-                    "rinsing_repeats": 0,
-                    "solid": False
-                }
+                "action_name": "wait",
+                "action_kwargs": {"time": eluting_wait_time}
             })
             
-            # 如果有过滤设备，再次过滤洗脱液
-            if filter_id:
+            # 洗脱间隔等待
+            if repeat_idx < eluting_repeats - 1:  # 不是最后一次洗脱
                 action_sequence.append({
-                    "device_id": filter_id,
-                    "action_name": "filter_sample",
-                    "action_kwargs": {
-                        "vessel": to_vessel,
-                        "filtrate_vessel": to_vessel,
-                        "stir": False,
-                        "stir_speed": 0.0,
-                        "temp": 25.0,
-                        "continue_heatchill": False,
-                        "volume": eluting_volume
-                    }
+                    "action_name": "wait",
+                    "action_kwargs": {"time": 10}
                 })
     
+    # === 第四步：最终等待，确保所有液体完全通过 ===
+    print(f"FILTER_THROUGH: 最终等待，确保所有液体完全通过过滤介质")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {"time": 20}
+    })
+    
+    print(f"FILTER_THROUGH: 生成了 {len(action_sequence)} 个动作")
+    print(f"FILTER_THROUGH: 通过过滤协议生成完成")
+    print(f"FILTER_THROUGH: 样品从 {from_vessel} 通过 {filter_through} 到达 {to_vessel}")
+    if eluting_repeats > 0:
+        total_eluting_volume = eluting_volume * eluting_repeats
+        print(f"FILTER_THROUGH: 总洗脱体积: {total_eluting_volume} mL {eluting_solvent}")
+    
     return action_sequence
+
+
+# 便捷函数：常用过滤方案
+def generate_gravity_column_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    column_material: str = "silica_gel"
+) -> List[Dict[str, Any]]:
+    """重力柱层析：简单重力过滤，无洗脱"""
+    return generate_filter_through_protocol(G, from_vessel, to_vessel, column_material, "", 0.0, 0, 0.0)
+
+
+def generate_celite_filter_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    wash_solvent: str = "ethanol",
+    wash_volume: float = 20.0
+) -> List[Dict[str, Any]]:
+    """硅藻土过滤：用于去除固体杂质"""
+    return generate_filter_through_protocol(G, from_vessel, to_vessel, "celite", wash_solvent, wash_volume, 1, 30.0)
+
+
+def generate_column_chromatography_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    column_material: str = "silica_gel",
+    eluting_solvent: str = "ethyl_acetate",
+    eluting_volume: float = 30.0,
+    eluting_repeats: int = 3
+) -> List[Dict[str, Any]]:
+    """柱层析：多次洗脱分离"""
+    return generate_filter_through_protocol(
+        G, from_vessel, to_vessel, column_material, eluting_solvent, eluting_volume, eluting_repeats, 60.0
+    )
+
+
+def generate_solid_phase_extraction_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    spe_cartridge: str = "C18",
+    eluting_solvent: str = "methanol",
+    eluting_volume: float = 15.0,
+    eluting_repeats: int = 2
+) -> List[Dict[str, Any]]:
+    """固相萃取：C18柱或其他SPE柱"""
+    return generate_filter_through_protocol(
+        G, from_vessel, to_vessel, spe_cartridge, eluting_solvent, eluting_volume, eluting_repeats, 120.0
+    )
+
+
+def generate_resin_filter_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    resin_type: str = "ion_exchange",
+    regeneration_solvent: str = "NaCl_solution",
+    regeneration_volume: float = 25.0
+) -> List[Dict[str, Any]]:
+    """树脂过滤：离子交换树脂或其他功能树脂"""
+    return generate_filter_through_protocol(
+        G, from_vessel, to_vessel, resin_type, regeneration_solvent, regeneration_volume, 1, 180.0
+    )
+
+
+def generate_multi_step_purification_protocol(
+    G: nx.DiGraph,
+    from_vessel: str,
+    to_vessel: str,
+    filter_steps: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """
+    多步骤纯化：连续多个过滤介质
+    
+    Args:
+        G: 网络图
+        from_vessel: 源容器
+        to_vessel: 最终目标容器
+        filter_steps: 过滤步骤列表，每个元素包含过滤参数
+    
+    Returns:
+        List[Dict[str, Any]]: 完整的动作序列
+    
+    Example:
+        filter_steps = [
+            {
+                "to_vessel": "intermediate_vessel_1",
+                "filter_through": "celite",
+                "eluting_solvent": "",
+                "eluting_volume": 0.0,
+                "eluting_repeats": 0,
+                "residence_time": 30.0
+            },
+            {
+                "from_vessel": "intermediate_vessel_1",
+                "to_vessel": "final_vessel",
+                "filter_through": "silica_gel",
+                "eluting_solvent": "ethyl_acetate",
+                "eluting_volume": 20.0,
+                "eluting_repeats": 2,
+                "residence_time": 60.0
+            }
+        ]
+    """
+    action_sequence = []
+    
+    current_from_vessel = from_vessel
+    
+    for i, step in enumerate(filter_steps):
+        print(f"FILTER_THROUGH: 处理第 {i+1}/{len(filter_steps)} 个过滤步骤")
+        
+        # 使用步骤中指定的参数，或使用默认值
+        step_from_vessel = step.get('from_vessel', current_from_vessel)
+        step_to_vessel = step.get('to_vessel', to_vessel if i == len(filter_steps) - 1 else f"intermediate_vessel_{i+1}")
+        
+        # 生成单个过滤步骤的协议
+        step_actions = generate_filter_through_protocol(
+            G=G,
+            from_vessel=step_from_vessel,
+            to_vessel=step_to_vessel,
+            filter_through=step.get('filter_through', 'silica_gel'),
+            eluting_solvent=step.get('eluting_solvent', ''),
+            eluting_volume=step.get('eluting_volume', 0.0),
+            eluting_repeats=step.get('eluting_repeats', 0),
+            residence_time=step.get('residence_time', 0.0)
+        )
+        
+        action_sequence.extend(step_actions)
+        
+        # 更新下一步的源容器
+        current_from_vessel = step_to_vessel
+        
+        # 在步骤之间加入等待时间
+        if i < len(filter_steps) - 1:  # 不是最后一个步骤
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {"time": 15}
+            })
+    
+    print(f"FILTER_THROUGH: 多步骤纯化协议生成完成，共 {len(action_sequence)} 个动作")
+    return action_sequence
+
+
+# 测试函数
+def test_filter_through_protocol():
+    """测试通过过滤协议的示例"""
+    print("=== FILTER THROUGH PROTOCOL 测试 ===")
+    print("测试完成")
+
+
+if __name__ == "__main__":
+    test_filter_through_protocol()

unilabos/compile/heatchill_protocol.py

@@ -1,117 +1,328 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
+from .utils.vessel_parser import get_vessel
+from .utils.unit_parser import parse_time_input
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[HEATCHILL] {message}")
+
+
+def parse_temp_input(temp_input: Union[str, float], default_temp: float = 25.0) -> float:
+    """
+    解析温度输入（统一函数）
+    
+    Args:
+        temp_input: 温度输入
+        default_temp: 默认温度
+        
+    Returns:
+        float: 温度（°C）
+    """
+    if not temp_input:
+        return default_temp
+    
+    # 🔢 数值输入
+    if isinstance(temp_input, (int, float)):
+        result = float(temp_input)
+        debug_print(f"🌡️ 数值温度: {temp_input} → {result}°C")
+        return result
+    
+    # 📝 字符串输入
+    temp_str = str(temp_input).lower().strip()
+    debug_print(f"🔍 解析温度: '{temp_str}'")
+    
+    # 🎯 特殊温度
+    special_temps = {
+        "room temperature": 25.0, "reflux": 78.0, "ice bath": 0.0,
+        "boiling": 100.0, "hot": 60.0, "warm": 40.0, "cold": 10.0
+    }
+    
+    if temp_str in special_temps:
+        result = special_temps[temp_str]
+        debug_print(f"🎯 特殊温度: '{temp_str}' → {result}°C")
+        return result
+    
+    # 📐 正则解析（如 "256 °C"）
+    temp_pattern = r'(\d+(?:\.\d+)?)\s*°?[cf]?'
+    match = re.search(temp_pattern, temp_str)
+    
+    if match:
+        result = float(match.group(1))
+        debug_print(f"✅ 温度解析: '{temp_str}' → {result}°C")
+        return result
+    
+    debug_print(f"⚠️ 无法解析温度: '{temp_str}'，使用默认值: {default_temp}°C")
+    return default_temp
+
+def find_connected_heatchill(G: nx.DiGraph, vessel: str) -> str:
+    """查找与指定容器相连的加热/冷却设备"""
+    debug_print(f"🔍 查找加热设备，目标容器: {vessel}")
+    
+    # 🔧 查找所有加热设备
+    heatchill_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'heatchill' in node_class.lower() or 'virtual_heatchill' in node_class:
+            heatchill_nodes.append(node)
+            debug_print(f"🎉 找到加热设备: {node}")
+    
+    # 🔗 检查连接
+    if vessel and heatchill_nodes:
+        for heatchill in heatchill_nodes:
+            if G.has_edge(heatchill, vessel) or G.has_edge(vessel, heatchill):
+                debug_print(f"✅ 加热设备 '{heatchill}' 与容器 '{vessel}' 相连")
+                return heatchill
+    
+    # 🎯 使用第一个可用设备
+    if heatchill_nodes:
+        selected = heatchill_nodes[0]
+        debug_print(f"🔧 使用第一个加热设备: {selected}")
+        return selected
+    
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到加热设备，使用默认设备")
+    return "heatchill_1"
+
+def validate_and_fix_params(temp: float, time: float, stir_speed: float) -> tuple:
+    """验证和修正参数"""
+    # 🌡️ 温度范围验证
+    if temp < -50.0 or temp > 300.0:
+        debug_print(f"⚠️ 温度 {temp}°C 超出范围，修正为 25°C")
+        temp = 25.0
+    else:
+        debug_print(f"✅ 温度 {temp}°C 在正常范围内")
+    
+    # ⏰ 时间验证
+    if time < 0:
+        debug_print(f"⚠️ 时间 {time}s 无效，修正为 300s")
+        time = 300.0
+    else:
+        debug_print(f"✅ 时间 {time}s ({time/60:.1f}分钟) 有效")
+    
+    # 🌪️ 搅拌速度验证
+    if stir_speed < 0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM")
+        stir_speed = 300.0
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内")
+    
+    return temp, time, stir_speed
 
 def generate_heat_chill_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    time: float,
-    stir: bool,
-    stir_speed: float,
-    purpose: str
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    temp: float = 25.0,
+    time: Union[str, float] = "300",
+    temp_spec: str = "",
+    time_spec: str = "",
+    pressure: str = "",
+    reflux_solvent: str = "",
+    stir: bool = False,
+    stir_speed: float = 300.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成加热/冷却操作的协议序列 - 严格按照 HeatChill.action
+    生成加热/冷却操作的协议序列 - 支持vessel字典
+    
+    Args:
+        G: 设备图
+        vessel: 容器字典（从XDL传入）
+        temp: 目标温度 (°C)
+        time: 加热时间（支持字符串如 "30 min"）
+        temp_spec: 温度规格说明（优先级高于temp）
+        time_spec: 时间规格说明（优先级高于time）
+        pressure: 压力设置
+        reflux_solvent: 回流溶剂
+        stir: 是否搅拌
+        stir_speed: 搅拌速度 (RPM)
+        purpose: 操作目的说明
+        **kwargs: 其他参数（兼容性）
+    
+    Returns:
+        List[Dict[str, Any]]: 加热/冷却操作的动作序列
     """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    debug_print("🌡️" * 20)
+    debug_print("🚀 开始生成加热冷却协议（支持vessel字典）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  🌡️ temp: {temp}°C")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🎯 temp_spec: {temp_spec}")
+    debug_print(f"  ⏱️ time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir: {stir} ({stir_speed} RPM)")
+    debug_print(f"  🎭 purpose: '{purpose}'")
+    debug_print("🌡️" * 20)
+    
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel_id:  # 🔧 使用 vessel_id
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
+        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
+    
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    #温度解析：优先使用 temp_spec
+    final_temp = parse_temp_input(temp_spec, temp) if temp_spec else temp
+    
+    # 时间解析：优先使用 time_spec
+    final_time = parse_time_input(time_spec) if time_spec else parse_time_input(time)
+    
+    # 参数修正
+    final_temp, final_time, stir_speed = validate_and_fix_params(final_temp, final_time, stir_speed)
+    
+    debug_print(f"🎯 最终参数: temp={final_temp}°C, time={final_time}s, stir_speed={stir_speed} RPM")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找加热设备... 🔍")
+    try:
+        heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"🎉 使用加热设备: {heatchill_id} ✨")
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"无法找到加热设备: {str(e)}")
+    
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成加热动作... 🔥")
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_time = final_time
+    simulation_time_limit = 100.0  # 模拟运行时间限制：100秒
+    
+    if final_time > simulation_time_limit:
+        final_time = simulation_time_limit
+        debug_print(f"  🎮 模拟运行优化: {original_time}s → {final_time}s (限制为{simulation_time_limit}s) ⚡")
+        debug_print(f"  📊 时间缩短: {original_time/60:.1f}分钟 → {final_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_time}s ({final_time/60:.1f}分钟) 保持不变 🎯")
+    
     action_sequence = []
-    
-    # 查找加热/冷却设备
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
-    
-    if not heatchill_nodes:
-        raise ValueError("没有找到可用的加热/冷却设备")
-    
-    heatchill_id = heatchill_nodes[0]
-    
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
-    
-    action_sequence.append({
+    heatchill_action = {
         "device_id": heatchill_id,
         "action_name": "heat_chill",
         "action_kwargs": {
-            "vessel": vessel,
-            "temp": temp,
-            "time": time,
-            "stir": stir,
-            "stir_speed": stir_speed,
-            "purpose": purpose
+            "vessel": {"id": vessel},
+            "temp": float(final_temp),
+            "time": float(final_time),
+            "stir": bool(stir),
+            "stir_speed": float(stir_speed),
+            "purpose": str(purpose or f"加热到 {final_temp}°C") + (f" (模拟时间: {final_time}s)" if original_time != final_time else "")
         }
-    })
+    }
+    action_sequence.append(heatchill_action)
+    debug_print("✅ 加热动作已添加 🔥✨")
+    
+    # 显示时间调整信息
+    if original_time != final_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_time/60:.1f}分钟，实际模拟 {final_time/60:.1f}分钟 ⚡")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 加热冷却协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 加热容器: {vessel_id}")
+    debug_print(f"🌡️ 目标温度: {final_temp}°C")
+    debug_print(f"⏰ 加热时间: {final_time}s ({final_time/60:.1f}分钟)")
+    debug_print("🎊" * 20)
     
     return action_sequence
 
+def generate_heat_chill_to_temp_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改参数类型
+    temp: float = 25.0,
+    time: Union[str, float] = 100.0,
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """生成加热到指定温度的协议（简化版）"""
+    vessel_id, _ = get_vessel(vessel)
+    debug_print(f"🌡️ 生成加热到温度协议: {vessel_id} → {temp}°C")
+    return generate_heat_chill_protocol(G, vessel, temp, time, **kwargs)
 
 def generate_heat_chill_start_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    temp: float,
-    purpose: str
+    vessel: dict,  # 🔧 修改参数类型
+    temp: float = 25.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成开始加热/冷却操作的协议序列 - 严格按照 HeatChillStart.action
-    """
-    action_sequence = []
+    """生成开始加热操作的协议序列"""
     
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, _ = get_vessel(vessel)
     
-    if not heatchill_nodes:
-        raise ValueError("没有找到可用的加热/冷却设备")
+    debug_print("🔥 开始生成启动加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id}), 🌡️ temp: {temp}°C")
     
-    heatchill_id = heatchill_nodes[0]
+    # 基础验证
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
+    # 查找设备
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
     
-    action_sequence.append({
+    # 生成动作
+    action_sequence = [{
         "device_id": heatchill_id,
         "action_name": "heat_chill_start",
         "action_kwargs": {
-            "vessel": vessel,
             "temp": temp,
-            "purpose": purpose
+            "purpose": purpose or f"开始加热到 {temp}°C",
+            "vessel": {"id": vessel_id},
         }
-    })
+    }]
     
+    debug_print(f"✅ 启动加热协议生成完成 🎯")
     return action_sequence
 
-
 def generate_heat_chill_stop_protocol(
     G: nx.DiGraph,
-    vessel: str
+    vessel: dict,  # 🔧 修改参数类型
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成停止加热/冷却操作的协议序列
+    """生成停止加热操作的协议序列"""
     
-    Args:
-        G: 有向图，节点为设备和容器
-        vessel: 容器名称
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, _ = get_vessel(vessel)
     
-    Returns:
-        List[Dict[str, Any]]: 停止加热/冷却操作的动作序列
-    """
-    action_sequence = []
+    debug_print("🛑 开始生成停止加热协议 ✨")
+    debug_print(f"🥽 vessel: {vessel} (ID: {vessel_id})")
     
-    # 查找加热/冷却设备
-    heatchill_nodes = [node for node in G.nodes() 
-                      if G.nodes[node].get('class') == 'virtual_heatchill']
+    # 基础验证
+    if not vessel_id or vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    if not heatchill_nodes:
-        raise ValueError("没有找到可用的加热/冷却设备")
+    # 查找设备
+    heatchill_id = find_connected_heatchill(G, vessel_id)  # 🔧 使用 vessel_id
     
-    heatchill_id = heatchill_nodes[0]
-    
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
-    
-    action_sequence.append({
+    # 生成动作
+    action_sequence = [{
         "device_id": heatchill_id,
         "action_name": "heat_chill_stop",
         "action_kwargs": {
-            "vessel": vessel
         }
-    })
+    }]
     
+    debug_print(f"✅ 停止加热协议生成完成 🎯")
     return action_sequence

unilabos/compile/hydrogenate_protocol.py

@@ -0,0 +1,458 @@
+import networkx as nx
+from typing import List, Dict, Any, Optional
+from .utils.vessel_parser import get_vessel
+
+
+def parse_temperature(temp_str: str) -> float:
+    """
+    解析温度字符串，支持多种格式
+    
+    Args:
+        temp_str: 温度字符串（如 "45 °C", "45°C", "45"）
+    
+    Returns:
+        float: 温度值（摄氏度）
+    """
+    try:
+        # 移除常见的温度单位和符号
+        temp_clean = temp_str.replace("°C", "").replace("°", "").replace("C", "").strip()
+        return float(temp_clean)
+    except ValueError:
+        print(f"HYDROGENATE: 无法解析温度 '{temp_str}'，使用默认温度 25°C")
+        return 25.0
+
+
+def parse_time(time_str: str) -> float:
+    """
+    解析时间字符串，支持多种格式
+    
+    Args:
+        time_str: 时间字符串（如 "2 h", "120 min", "7200 s"）
+    
+    Returns:
+        float: 时间值（秒）
+    """
+    try:
+        time_clean = time_str.lower().strip()
+        
+        # 处理小时
+        if "h" in time_clean:
+            hours = float(time_clean.replace("h", "").strip())
+            return hours * 3600.0
+        
+        # 处理分钟
+        if "min" in time_clean:
+            minutes = float(time_clean.replace("min", "").strip())
+            return minutes * 60.0
+        
+        # 处理秒
+        if "s" in time_clean:
+            seconds = float(time_clean.replace("s", "").strip())
+            return seconds
+        
+        # 默认按小时处理
+        return float(time_clean) * 3600.0
+    
+    except ValueError:
+        print(f"HYDROGENATE: 无法解析时间 '{time_str}'，使用默认时间 2小时")
+        return 7200.0  # 2小时
+
+
+def find_associated_solenoid_valve(G: nx.DiGraph, device_id: str) -> Optional[str]:
+    """查找与指定设备相关联的电磁阀"""
+    solenoid_valves = [
+        node for node in G.nodes() 
+        if ('solenoid' in (G.nodes[node].get('class') or '').lower()
+            or 'solenoid_valve' in node)
+    ]
+    
+    # 通过网络连接查找直接相连的电磁阀
+    for solenoid in solenoid_valves:
+        if G.has_edge(device_id, solenoid) or G.has_edge(solenoid, device_id):
+            return solenoid
+    
+    # 通过命名规则查找关联的电磁阀
+    device_type = ""
+    if 'gas' in device_id.lower():
+        device_type = "gas"
+    elif 'h2' in device_id.lower() or 'hydrogen' in device_id.lower():
+        device_type = "gas"
+    
+    if device_type:
+        for solenoid in solenoid_valves:
+            if device_type in solenoid.lower():
+                return solenoid
+    
+    return None
+
+
+def find_connected_device(G: nx.DiGraph, vessel: str, device_type: str) -> str:
+    """
+    查找与容器相连的指定类型设备
+    
+    Args:
+        G: 网络图
+        vessel: 容器名称
+        device_type: 设备类型 ('heater', 'stirrer', 'gas_source')
+    
+    Returns:
+        str: 设备ID，如果没有则返回None
+    """
+    print(f"HYDROGENATE: 正在查找与容器 '{vessel}' 相连的 {device_type}...")
+    
+    # 根据设备类型定义搜索关键词
+    if device_type == 'heater':
+        keywords = ['heater', 'heat', 'heatchill']
+        device_class = 'virtual_heatchill'
+    elif device_type == 'stirrer':
+        keywords = ['stirrer', 'stir']
+        device_class = 'virtual_stirrer'
+    elif device_type == 'gas_source':
+        keywords = ['gas', 'h2', 'hydrogen']
+        device_class = 'virtual_gas_source'
+    else:
+        return None
+    
+    # 查找设备节点
+    device_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_name = node.lower()
+        node_class = node_data.get('class', '').lower()
+        
+        # 通过名称匹配
+        if any(keyword in node_name for keyword in keywords):
+            device_nodes.append(node)
+        # 通过类型匹配
+        elif device_class in node_class:
+            device_nodes.append(node)
+    
+    print(f"HYDROGENATE: 找到的{device_type}节点: {device_nodes}")
+    
+    # 检查是否有设备与目标容器相连
+    for device in device_nodes:
+        if G.has_edge(device, vessel) or G.has_edge(vessel, device):
+            print(f"HYDROGENATE: 找到与容器 '{vessel}' 相连的{device_type}: {device}")
+            return device
+    
+    # 如果没有直接连接，查找距离最近的设备
+    for device in device_nodes:
+        try:
+            path = nx.shortest_path(G, source=device, target=vessel)
+            if len(path) <= 3:  # 最多2个中间节点
+                print(f"HYDROGENATE: 找到距离较近的{device_type}: {device}")
+                return device
+        except nx.NetworkXNoPath:
+            continue
+    
+    print(f"HYDROGENATE: 未找到与容器 '{vessel}' 相连的{device_type}")
+    return None
+
+
+def generate_hydrogenate_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    temp: str,
+    time: str,
+    **kwargs  # 接收其他可能的参数但不使用
+) -> List[Dict[str, Any]]:
+    """
+    生成氢化反应协议序列 - 支持vessel字典
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 反应容器字典（从XDL传入）
+        temp: 反应温度（如 "45 °C"）
+        time: 反应时间（如 "2 h"）
+        **kwargs: 其他可选参数，但不使用
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    action_sequence = []
+    
+    # 解析参数
+    temperature = parse_temperature(temp)
+    reaction_time = parse_time(time)
+    
+    print("🧪" * 20)
+    print(f"HYDROGENATE: 开始生成氢化反应协议（支持vessel字典）✨")
+    print(f"📝 输入参数:")
+    print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    print(f"  🌡️ 反应温度: {temperature}°C")
+    print(f"  ⏰ 反应时间: {reaction_time/3600:.1f} 小时")
+    print("🧪" * 20)
+    
+    # 🔧 新增：记录氢化前的容器状态（可选，氢化反应通常不改变体积）
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    print(f"📊 氢化前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # 1. 验证目标容器存在
+    print("📍 步骤1: 验证目标容器...")
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        print(f"⚠️ HYDROGENATE: 警告 - 容器 '{vessel_id}' 不存在于系统中，跳过氢化反应")
+        return action_sequence
+    print(f"✅ 容器 '{vessel_id}' 验证通过")
+    
+    # 2. 查找相连的设备
+    print("📍 步骤2: 查找相连设备...")
+    heater_id = find_connected_device(G, vessel_id, 'heater')  # 🔧 使用 vessel_id
+    stirrer_id = find_connected_device(G, vessel_id, 'stirrer')  # 🔧 使用 vessel_id
+    gas_source_id = find_connected_device(G, vessel_id, 'gas_source')  # 🔧 使用 vessel_id
+    
+    print(f"🔧 设备配置:")
+    print(f"  🔥 加热器: {heater_id or '未找到'}")
+    print(f"  🌪️ 搅拌器: {stirrer_id or '未找到'}")
+    print(f"  💨 气源: {gas_source_id or '未找到'}")
+    
+    # 3. 启动搅拌器
+    print("📍 步骤3: 启动搅拌器...")
+    if stirrer_id:
+        print(f"🌪️ 启动搅拌器 {stirrer_id}")
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "start_stir",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "stir_speed": 300.0,
+                "purpose": "氢化反应: 开始搅拌"
+            }
+        })
+        print("✅ 搅拌器启动动作已添加")
+    else:
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到搅拌器，继续执行")
+    
+    # 4. 启动气源（氢气）
+    print("📍 步骤4: 启动氢气源...")
+    if gas_source_id:
+        print(f"💨 启动气源 {gas_source_id} (氢气)")
+        action_sequence.append({
+            "device_id": gas_source_id,
+            "action_name": "set_status",
+            "action_kwargs": {
+                "string": "ON"
+            }
+        })
+        
+        # 查找相关的电磁阀
+        gas_solenoid = find_associated_solenoid_valve(G, gas_source_id)
+        if gas_solenoid:
+            print(f"🚪 开启气源电磁阀 {gas_solenoid}")
+            action_sequence.append({
+                "device_id": gas_solenoid,
+                "action_name": "set_valve_position",
+                "action_kwargs": {
+                    "command": "OPEN"
+                }
+            })
+        print("✅ 氢气源启动动作已添加")
+    else:
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到气源，继续执行")
+    
+    # 5. 等待气体稳定
+    print("📍 步骤5: 等待气体环境稳定...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 30.0,
+            "description": "等待氢气环境稳定"
+        }
+    })
+    print("✅ 气体稳定等待动作已添加")
+    
+    # 6. 启动加热器
+    print("📍 步骤6: 启动加热反应...")
+    if heater_id:
+        print(f"🔥 启动加热器 {heater_id} 到 {temperature}°C")
+        action_sequence.append({
+            "device_id": heater_id,
+            "action_name": "heat_chill_start",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "temp": temperature,
+                "purpose": f"氢化反应: 加热到 {temperature}°C"
+            }
+        })
+        
+        # 等待温度稳定
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 20.0,
+                "description": f"等待温度稳定到 {temperature}°C"
+            }
+        })
+        
+        # 🕐 模拟运行时间优化
+        print("  ⏰ 检查模拟运行时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            print(f"  🎮 模拟运行优化: {original_reaction_time}s → {reaction_time}s (限制为{simulation_time_limit}s)")
+            print(f"  📊 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"  ✅ 时间在限制内: {reaction_time}s ({reaction_time/60:.1f}分钟) 保持不变")
+        
+        # 保持反应温度
+        action_sequence.append({
+            "device_id": heater_id,
+            "action_name": "heat_chill",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "temp": temperature,
+                "time": reaction_time,
+                "purpose": f"氢化反应: 保持 {temperature}°C，反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
+            }
+        })
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"  🎭 模拟优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
+        
+        print("✅ 加热反应动作已添加")
+            
+    else:
+        print(f"⚠️ HYDROGENATE: 警告 - 未找到加热器，使用室温反应")
+        
+        # 🕐 室温反应也需要时间优化
+        print("  ⏰ 检查室温反应模拟时间限制...")
+        original_reaction_time = reaction_time
+        simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+        
+        if reaction_time > simulation_time_limit:
+            reaction_time = simulation_time_limit
+            print(f"  🎮 室温反应时间优化: {original_reaction_time}s → {reaction_time}s")
+            print(f"  📊 时间缩短: {original_reaction_time/3600:.2f}小时 → {reaction_time/60:.1f}分钟")
+        else:
+            print(f"  ✅ 室温反应时间在限制内: {reaction_time}s 保持不变")
+        
+        # 室温反应，只等待时间
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": reaction_time,
+                "description": f"室温氢化反应 {reaction_time/60:.1f}分钟" + (f" (模拟时间)" if original_reaction_time != reaction_time else "")
+            }
+        })
+        
+        # 显示时间调整信息
+        if original_reaction_time != reaction_time:
+            print(f"  🎭 室温反应优化说明: 原计划 {original_reaction_time/3600:.2f}小时，实际模拟 {reaction_time/60:.1f}分钟")
+        
+        print("✅ 室温反应等待动作已添加")
+    
+    # 7. 停止加热
+    print("📍 步骤7: 停止加热...")
+    if heater_id:
+        action_sequence.append({
+            "device_id": heater_id,
+            "action_name": "heat_chill_stop",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "purpose": "氢化反应完成，停止加热"
+            }
+        })
+        print("✅ 停止加热动作已添加")
+    
+    # 8. 等待冷却
+    print("📍 步骤8: 等待冷却...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 300.0,
+            "description": "等待反应混合物冷却"
+        }
+    })
+    print("✅ 冷却等待动作已添加")
+    
+    # 9. 停止气源
+    print("📍 步骤9: 停止氢气源...")
+    if gas_source_id:
+        # 先关闭电磁阀
+        gas_solenoid = find_associated_solenoid_valve(G, gas_source_id)
+        if gas_solenoid:
+            print(f"🚪 关闭气源电磁阀 {gas_solenoid}")
+            action_sequence.append({
+                "device_id": gas_solenoid,
+                "action_name": "set_valve_position",
+                "action_kwargs": {
+                    "command": "CLOSED"
+                }
+            })
+        
+        # 再关闭气源
+        action_sequence.append({
+            "device_id": gas_source_id,
+            "action_name": "set_status",
+            "action_kwargs": {
+                "string": "OFF"
+            }
+        })
+        print("✅ 氢气源停止动作已添加")
+    
+    # 10. 停止搅拌
+    print("📍 步骤10: 停止搅拌...")
+    if stirrer_id:
+        action_sequence.append({
+            "device_id": stirrer_id,
+            "action_name": "stop_stir",
+            "action_kwargs": {
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
+                "purpose": "氢化反应完成，停止搅拌"
+            }
+        })
+        print("✅ 停止搅拌动作已添加")
+    
+    # 🔧 新增：氢化完成后的状态（氢化反应通常不改变体积）
+    final_liquid_volume = original_liquid_volume  # 氢化反应体积基本不变
+    
+    # 总结
+    print("🎊" * 20)
+    print(f"🎉 氢化反应协议生成完成! ✨")
+    print(f"📊 总动作数: {len(action_sequence)} 个")
+    print(f"🥽 反应容器: {vessel_id}")
+    print(f"🌡️ 反应温度: {temperature}°C")
+    print(f"⏰ 反应时间: {reaction_time/60:.1f}分钟")
+    print(f"⏱️ 预计总时间: {(reaction_time + 450)/3600:.1f} 小时")
+    print(f"📊 体积状态:")
+    print(f"  - 反应前体积: {original_liquid_volume:.2f}mL")
+    print(f"  - 反应后体积: {final_liquid_volume:.2f}mL (氢化反应体积基本不变)")
+    print("🎊" * 20)
+    
+    return action_sequence
+
+
+# 测试函数
+def test_hydrogenate_protocol():
+    """测试氢化反应协议"""
+    print("🧪 === HYDROGENATE PROTOCOL 测试 === ✨")
+    
+    # 测试温度解析
+    test_temps = ["45 °C", "45°C", "45", "25 C", "invalid"]
+    for temp in test_temps:
+        parsed = parse_temperature(temp)
+        print(f"温度 '{temp}' -> {parsed}°C")
+    
+    # 测试时间解析
+    test_times = ["2 h", "120 min", "7200 s", "2", "invalid"]
+    for time in test_times:
+        parsed = parse_time(time)
+        print(f"时间 '{time}' -> {parsed/3600:.1f} 小时")
+    
+    print("✅ 测试完成 🎉")
+
+
+if __name__ == "__main__":
+    test_hydrogenate_protocol()

unilabos/compile/recrystallize_protocol.py

@@ -0,0 +1,390 @@
+import networkx as nx
+import re
+import logging
+from typing import List, Dict, Any, Tuple, Union
+from .utils.vessel_parser import get_vessel, find_solvent_vessel
+from .utils.unit_parser import parse_volume_input
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[RECRYSTALLIZE] {message}")
+
+
+def parse_ratio(ratio_str: str) -> Tuple[float, float]:
+    """
+    解析比例字符串，支持多种格式
+    
+    Args:
+        ratio_str: 比例字符串（如 "1:1", "3:7", "50:50"）
+    
+    Returns:
+        Tuple[float, float]: 比例元组 (ratio1, ratio2)
+    """
+    debug_print(f"⚖️ 开始解析比例: '{ratio_str}' 📊")
+    
+    try:
+        # 处理 "1:1", "3:7", "50:50" 等格式
+        if ":" in ratio_str:
+            parts = ratio_str.split(":")
+            if len(parts) == 2:
+                ratio1 = float(parts[0])
+                ratio2 = float(parts[1])
+                debug_print(f"✅ 冒号格式解析成功: {ratio1}:{ratio2} 🎯")
+                return ratio1, ratio2
+        
+        # 处理 "1-1", "3-7" 等格式
+        if "-" in ratio_str:
+            parts = ratio_str.split("-")
+            if len(parts) == 2:
+                ratio1 = float(parts[0])
+                ratio2 = float(parts[1])
+                debug_print(f"✅ 横线格式解析成功: {ratio1}:{ratio2} 🎯")
+                return ratio1, ratio2
+        
+        # 处理 "1,1", "3,7" 等格式
+        if "," in ratio_str:
+            parts = ratio_str.split(",")
+            if len(parts) == 2:
+                ratio1 = float(parts[0])
+                ratio2 = float(parts[1])
+                debug_print(f"✅ 逗号格式解析成功: {ratio1}:{ratio2} 🎯")
+                return ratio1, ratio2
+        
+        # 默认 1:1
+        debug_print(f"⚠️ 无法解析比例 '{ratio_str}'，使用默认比例 1:1 🎭")
+        return 1.0, 1.0
+    
+    except ValueError:
+        debug_print(f"❌ 比例解析错误 '{ratio_str}'，使用默认比例 1:1 🎭")
+        return 1.0, 1.0
+
+
+def generate_recrystallize_protocol(
+    G: nx.DiGraph,
+    vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    ratio: str,
+    solvent1: str,
+    solvent2: str,
+    volume: Union[str, float],  # 支持字符串和数值
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """
+    生成重结晶协议序列 - 支持vessel字典和体积运算
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        vessel: 目标容器字典（从XDL传入）
+        ratio: 溶剂比例（如 "1:1", "3:7"）
+        solvent1: 第一种溶剂名称
+        solvent2: 第二种溶剂名称
+        volume: 总体积（支持 "100 mL", "50", "2.5 L" 等）
+        **kwargs: 其他可选参数
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    vessel_id, vessel_data = get_vessel(vessel)
+    
+    action_sequence = []
+    
+    debug_print("💎" * 20)
+    debug_print("🚀 开始生成重结晶协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel} (ID: {vessel_id})")
+    debug_print(f"  ⚖️ 比例: {ratio}")
+    debug_print(f"  🧪 溶剂1: {solvent1}")
+    debug_print(f"  🧪 溶剂2: {solvent2}")
+    debug_print(f"  💧 总体积: {volume} (类型: {type(volume)})")
+    debug_print("💎" * 20)
+    
+    # 🔧 新增：记录重结晶前的容器状态
+    debug_print("🔍 记录重结晶前容器状态...")
+    original_liquid_volume = 0.0
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list) and len(current_volume) > 0:
+            original_liquid_volume = current_volume[0]
+        elif isinstance(current_volume, (int, float)):
+            original_liquid_volume = current_volume
+    debug_print(f"📊 重结晶前液体体积: {original_liquid_volume:.2f}mL")
+    
+    # 1. 验证目标容器存在
+    debug_print("📍 步骤1: 验证目标容器... 🔧")
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 目标容器 '{vessel_id}' 不存在于系统中! 😱")
+        raise ValueError(f"目标容器 '{vessel_id}' 不存在于系统中")
+    debug_print(f"✅ 目标容器 '{vessel_id}' 验证通过 🎯")
+    
+    # 2. 解析体积（支持单位）
+    debug_print("📍 步骤2: 解析体积（支持单位）... 💧")
+    final_volume = parse_volume_input(volume, "mL")
+    debug_print(f"🎯 体积解析完成: {volume} → {final_volume}mL ✨")
+    
+    # 3. 解析比例
+    debug_print("📍 步骤3: 解析比例... ⚖️")
+    ratio1, ratio2 = parse_ratio(ratio)
+    total_ratio = ratio1 + ratio2
+    debug_print(f"🎯 比例解析完成: {ratio1}:{ratio2} (总比例: {total_ratio}) ✨")
+    
+    # 4. 计算各溶剂体积
+    debug_print("📍 步骤4: 计算各溶剂体积... 🧮")
+    volume1 = final_volume * (ratio1 / total_ratio)
+    volume2 = final_volume * (ratio2 / total_ratio)
+    
+    debug_print(f"🧪 {solvent1} 体积: {volume1:.2f} mL ({ratio1}/{total_ratio} × {final_volume})")
+    debug_print(f"🧪 {solvent2} 体积: {volume2:.2f} mL ({ratio2}/{total_ratio} × {final_volume})")
+    debug_print(f"✅ 体积计算完成: 总计 {volume1 + volume2:.2f} mL 🎯")
+    
+    # 5. 查找溶剂容器
+    debug_print("📍 步骤5: 查找溶剂容器... 🔍")
+    try:
+        debug_print(f"  🔍 查找溶剂1容器...")
+        solvent1_vessel = find_solvent_vessel(G, solvent1)
+        debug_print(f"  🎉 找到溶剂1容器: {solvent1_vessel} ✨")
+    except ValueError as e:
+        debug_print(f"  ❌ 溶剂1容器查找失败: {str(e)} 😭")
+        raise ValueError(f"无法找到溶剂1 '{solvent1}': {str(e)}")
+    
+    try:
+        debug_print(f"  🔍 查找溶剂2容器...")
+        solvent2_vessel = find_solvent_vessel(G, solvent2)
+        debug_print(f"  🎉 找到溶剂2容器: {solvent2_vessel} ✨")
+    except ValueError as e:
+        debug_print(f"  ❌ 溶剂2容器查找失败: {str(e)} 😭")
+        raise ValueError(f"无法找到溶剂2 '{solvent2}': {str(e)}")
+    
+    # 6. 验证路径存在
+    debug_print("📍 步骤6: 验证传输路径... 🛤️")
+    try:
+        path1 = nx.shortest_path(G, source=solvent1_vessel, target=vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"  🛤️ 溶剂1路径: {' → '.join(path1)} ✅")
+    except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂1路径不可达: {solvent1_vessel} → {vessel_id} 😞")
+        raise ValueError(f"从溶剂1容器 '{solvent1_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
+    
+    try:
+        path2 = nx.shortest_path(G, source=solvent2_vessel, target=vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"  🛤️ 溶剂2路径: {' → '.join(path2)} ✅")
+    except nx.NetworkXNoPath:
+        debug_print(f"  ❌ 溶剂2路径不可达: {solvent2_vessel} → {vessel_id} 😞")
+        raise ValueError(f"从溶剂2容器 '{solvent2_vessel}' 到目标容器 '{vessel_id}' 没有可用路径")
+    
+    # 7. 添加第一种溶剂
+    debug_print("📍 步骤7: 添加第一种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂1: {solvent1} ({volume1:.2f} mL)")
+    
+    try:
+        pump_actions1 = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=solvent1_vessel,
+            to_vessel=vessel_id,  # 🔧 使用 vessel_id
+            volume=volume1,             # 使用解析后的体积
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重结晶不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=2.0,  # 正常流速
+            transfer_flowrate=0.5
+        )
+        
+        action_sequence.extend(pump_actions1)
+        debug_print(f"  ✅ 溶剂1泵送动作已添加: {len(pump_actions1)} 个动作 🚰✨")
+        
+    except Exception as e:
+        debug_print(f"  ❌ 溶剂1泵协议生成失败: {str(e)} 😭")
+        raise ValueError(f"生成溶剂1泵协议时出错: {str(e)}")
+    
+    # 🔧 新增：更新容器体积 - 添加溶剂1后
+    debug_print("  🔧 更新容器体积 - 添加溶剂1后...")
+    new_volume_after_solvent1 = original_liquid_volume + volume1
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list):
+            if len(current_volume) > 0:
+                vessel["data"]["liquid_volume"][0] = new_volume_after_solvent1
+            else:
+                vessel["data"]["liquid_volume"] = [new_volume_after_solvent1]
+        else:
+            vessel["data"]["liquid_volume"] = new_volume_after_solvent1
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume_after_solvent1
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume_after_solvent1]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume_after_solvent1
+    
+    debug_print(f"  📊 体积更新: {original_liquid_volume:.2f}mL + {volume1:.2f}mL = {new_volume_after_solvent1:.2f}mL")
+    
+    # 8. 等待溶剂1稳定
+    debug_print("  ⏳ 添加溶剂1稳定等待...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 5.0,  # 缩短等待时间
+            "description": f"等待溶剂1 {solvent1} 稳定"
+        }
+    })
+    debug_print("  ✅ 溶剂1稳定等待已添加 ⏰✨")
+    
+    # 9. 添加第二种溶剂
+    debug_print("📍 步骤8: 添加第二种溶剂... 🧪")
+    debug_print(f"  🚰 开始添加溶剂2: {solvent2} ({volume2:.2f} mL)")
+    
+    try:
+        pump_actions2 = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=solvent2_vessel,
+            to_vessel=vessel_id,  # 🔧 使用 vessel_id
+            volume=volume2,             # 使用解析后的体积
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重结晶不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=2.0,  # 正常流速
+            transfer_flowrate=0.5
+        )
+        
+        action_sequence.extend(pump_actions2)
+        debug_print(f"  ✅ 溶剂2泵送动作已添加: {len(pump_actions2)} 个动作 🚰✨")
+        
+    except Exception as e:
+        debug_print(f"  ❌ 溶剂2泵协议生成失败: {str(e)} 😭")
+        raise ValueError(f"生成溶剂2泵协议时出错: {str(e)}")
+    
+    # 🔧 新增：更新容器体积 - 添加溶剂2后
+    debug_print("  🔧 更新容器体积 - 添加溶剂2后...")
+    final_liquid_volume = new_volume_after_solvent1 + volume2
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel and "liquid_volume" in vessel["data"]:
+        current_volume = vessel["data"]["liquid_volume"]
+        if isinstance(current_volume, list):
+            if len(current_volume) > 0:
+                vessel["data"]["liquid_volume"][0] = final_liquid_volume
+            else:
+                vessel["data"]["liquid_volume"] = [final_liquid_volume]
+        else:
+            vessel["data"]["liquid_volume"] = final_liquid_volume
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = final_liquid_volume
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [final_liquid_volume]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = final_liquid_volume
+    
+    debug_print(f"  📊 最终体积: {new_volume_after_solvent1:.2f}mL + {volume2:.2f}mL = {final_liquid_volume:.2f}mL")
+    
+    # 10. 等待溶剂2稳定
+    debug_print("  ⏳ 添加溶剂2稳定等待...")
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": 5.0,  # 缩短等待时间
+            "description": f"等待溶剂2 {solvent2} 稳定"
+        }
+    })
+    debug_print("  ✅ 溶剂2稳定等待已添加 ⏰✨")
+    
+    # 11. 等待重结晶完成
+    debug_print("📍 步骤9: 等待重结晶完成... 💎")
+    
+    # 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_crystallize_time = 600.0  # 原始重结晶时间
+    simulation_time_limit = 60.0  # 模拟运行时间限制：60秒
+
+    final_crystallize_time = min(original_crystallize_time, simulation_time_limit)
+    
+    if original_crystallize_time > simulation_time_limit:
+        debug_print(f"  🎮 模拟运行优化: {original_crystallize_time}s → {final_crystallize_time}s ⚡")
+        debug_print(f"  📊 时间缩短: {original_crystallize_time/60:.1f}分钟 → {final_crystallize_time/60:.1f}分钟 🚀")
+    else:
+        debug_print(f"  ✅ 时间在限制内: {final_crystallize_time}s 保持不变 🎯")
+    
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": final_crystallize_time,
+            "description": f"等待重结晶完成（{solvent1}:{solvent2} = {ratio}，总体积 {final_volume}mL）" + (f" (模拟时间)" if original_crystallize_time != final_crystallize_time else "")
+        }
+    })
+    debug_print(f"  ✅ 重结晶等待已添加: {final_crystallize_time}s 💎✨")
+    
+    # 显示时间调整信息
+    if original_crystallize_time != final_crystallize_time:
+        debug_print(f"  🎭 模拟优化说明: 原计划 {original_crystallize_time/60:.1f}分钟，实际模拟 {final_crystallize_time/60:.1f}分钟 ⚡")
+    
+    # 总结
+    debug_print("💎" * 20)
+    debug_print(f"🎉 重结晶协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 目标容器: {vessel_id}")
+    debug_print(f"💧 总体积变化:")
+    debug_print(f"  - 原始体积: {original_liquid_volume:.2f}mL")
+    debug_print(f"  - 添加溶剂: {final_volume:.2f}mL")
+    debug_print(f"  - 最终体积: {final_liquid_volume:.2f}mL")
+    debug_print(f"⚖️ 溶剂比例: {solvent1}:{solvent2} = {ratio1}:{ratio2}")
+    debug_print(f"🧪 溶剂1: {solvent1} ({volume1:.2f}mL)")
+    debug_print(f"🧪 溶剂2: {solvent2} ({volume2:.2f}mL)")
+    debug_print(f"⏱️ 预计总时间: {(final_crystallize_time + 10)/60:.1f} 分钟 ⌛")
+    debug_print("💎" * 20)
+    
+    return action_sequence
+
+
+# 测试函数
+def test_recrystallize_protocol():
+    """测试重结晶协议"""
+    debug_print("🧪 === RECRYSTALLIZE PROTOCOL 测试 === ✨")
+    
+    # 测试体积解析
+    debug_print("💧 测试体积解析...")
+    test_volumes = ["100 mL", "2.5 L", "500", "50.5", "?", "invalid"]
+    for vol in test_volumes:
+        parsed = parse_volume_input(vol)
+        debug_print(f"  📊 体积 '{vol}' -> {parsed}mL")
+    
+    # 测试比例解析
+    debug_print("⚖️ 测试比例解析...")
+    test_ratios = ["1:1", "3:7", "50:50", "1-1", "2,8", "invalid"]
+    for ratio in test_ratios:
+        r1, r2 = parse_ratio(ratio)
+        debug_print(f"  📊 比例 '{ratio}' -> {r1}:{r2}")
+    
+    debug_print("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_recrystallize_protocol()

unilabos/compile/reset_handling_protocol.py

@@ -0,0 +1,387 @@
+import networkx as nx
+import logging
+import sys
+from typing import List, Dict, Any, Optional
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+# 设置日志
+logger = logging.getLogger(__name__)
+
+# 确保输出编码为UTF-8
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except:
+        pass
+
+def debug_print(message):
+    """调试输出函数 - 支持中文"""
+    try:
+        # 确保消息是字符串格式
+        safe_message = str(message)
+        print(f"[重置处理] {safe_message}", flush=True)
+        logger.info(f"[重置处理] {safe_message}")
+    except UnicodeEncodeError:
+        # 如果编码失败，尝试替换不支持的字符
+        safe_message = str(message).encode('utf-8', errors='replace').decode('utf-8')
+        print(f"[重置处理] {safe_message}", flush=True)
+        logger.info(f"[重置处理] {safe_message}")
+    except Exception as e:
+        # 最后的安全措施
+        fallback_message = f"日志输出错误: {repr(message)}"
+        print(f"[重置处理] {fallback_message}", flush=True)
+        logger.info(f"[重置处理] {fallback_message}")
+
+def create_action_log(message: str, emoji: str = "📝") -> Dict[str, Any]:
+    """创建一个动作日志 - 支持中文和emoji"""
+    try:
+        full_message = f"{emoji} {message}"
+        debug_print(full_message)
+        logger.info(full_message)
+        
+        return {
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": full_message,
+                "progress_message": full_message
+            }
+        }
+    except Exception as e:
+        # 如果emoji有问题，使用纯文本
+        safe_message = f"[日志] {message}"
+        debug_print(safe_message)
+        logger.info(safe_message)
+        
+        return {
+            "action_name": "wait", 
+            "action_kwargs": {
+                "time": 0.1,
+                "log_message": safe_message,
+                "progress_message": safe_message
+            }
+        }
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """
+    查找溶剂容器，支持多种匹配模式
+    
+    Args:
+        G: 网络图
+        solvent: 溶剂名称（如 "methanol", "ethanol", "water"）
+    
+    Returns:
+        str: 溶剂容器ID
+    """
+    debug_print(f"🔍 正在查找溶剂 '{solvent}' 的容器...")
+    
+    # 构建可能的容器名称
+    possible_names = [
+        f"flask_{solvent}",           # flask_methanol
+        f"bottle_{solvent}",          # bottle_methanol
+        f"reagent_{solvent}",         # reagent_methanol
+        f"reagent_bottle_{solvent}",  # reagent_bottle_methanol
+        f"{solvent}_flask",           # methanol_flask
+        f"{solvent}_bottle",          # methanol_bottle
+        f"{solvent}",                 # methanol
+        f"vessel_{solvent}",          # vessel_methanol
+    ]
+    
+    debug_print(f"🎯 候选容器名称: {possible_names[:3]}... (共{len(possible_names)}个)")
+    
+    # 第一步：通过容器名称匹配
+    debug_print("📋 方法1: 精确名称匹配...")
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            debug_print(f"✅ 通过名称匹配找到容器: {vessel_name}")
+            return vessel_name
+    debug_print("⚠️ 精确名称匹配失败，尝试模糊匹配...")
+    
+    # 第二步：通过模糊匹配
+    debug_print("📋 方法2: 模糊名称匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            node_name = G.nodes[node_id].get('name', '').lower()
+            
+            # 检查是否包含溶剂名称
+            if solvent.lower() in node_id.lower() or solvent.lower() in node_name:
+                debug_print(f"✅ 通过模糊匹配找到容器: {node_id}")
+                return node_id
+    debug_print("⚠️ 模糊匹配失败，尝试液体类型匹配...")
+    
+    # 第三步：通过液体类型匹配
+    debug_print("📋 方法3: 液体类型匹配...")
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            
+            for liquid in liquids:
+                if isinstance(liquid, dict):
+                    liquid_type = (liquid.get('liquid_type') or liquid.get('name', '')).lower()
+                    reagent_name = vessel_data.get('reagent_name', '').lower()
+                    
+                    if solvent.lower() in liquid_type or solvent.lower() in reagent_name:
+                        debug_print(f"✅ 通过液体类型匹配找到容器: {node_id}")
+                        return node_id
+    
+    # 列出可用容器帮助调试
+    debug_print("📊 显示可用容器信息...")
+    available_containers = []
+    for node_id in G.nodes():
+        if G.nodes[node_id].get('type') == 'container':
+            vessel_data = G.nodes[node_id].get('data', {})
+            liquids = vessel_data.get('liquid', [])
+            liquid_types = [liquid.get('liquid_type', '') or liquid.get('name', '') 
+                           for liquid in liquids if isinstance(liquid, dict)]
+            
+            available_containers.append({
+                'id': node_id,
+                'name': G.nodes[node_id].get('name', ''),
+                'liquids': liquid_types,
+                'reagent_name': vessel_data.get('reagent_name', '')
+            })
+    
+    debug_print(f"📋 可用容器列表 (共{len(available_containers)}个):")
+    for i, container in enumerate(available_containers[:5]):  # 只显示前5个
+        debug_print(f"  {i+1}. 🥽 {container['id']}: {container['name']}")
+        debug_print(f"     💧 液体: {container['liquids']}")
+        debug_print(f"     🧪 试剂: {container['reagent_name']}")
+    
+    if len(available_containers) > 5:
+        debug_print(f"    ... 还有 {len(available_containers)-5} 个容器")
+    
+    debug_print(f"❌ 找不到溶剂 '{solvent}' 对应的容器")
+    raise ValueError(f"找不到溶剂 '{solvent}' 对应的容器。尝试了: {possible_names[:3]}...")
+
+def generate_reset_handling_protocol(
+    G: nx.DiGraph,
+    solvent: str,
+    vessel: Optional[str] = None,  # 🆕 新增可选vessel参数
+    **kwargs  # 接收其他可能的参数但不使用
+) -> List[Dict[str, Any]]:
+    """
+    生成重置处理协议序列 - 支持自定义容器
+    
+    Args:
+        G: 有向图，节点为容器和设备
+        solvent: 溶剂名称（从XDL传入）
+        vessel: 目标容器名称（可选，默认为 "main_reactor"）
+        **kwargs: 其他可选参数，但不使用
+    
+    Returns:
+        List[Dict[str, Any]]: 动作序列
+    """
+    action_sequence = []
+    
+    # 🔧 修改：支持自定义vessel参数
+    target_vessel = vessel if vessel is not None else "main_reactor"  # 默认目标容器
+    volume = 50.0  # 默认体积 50 mL
+
+    debug_print("=" * 60)
+    debug_print("🚀 开始生成重置处理协议")
+    debug_print(f"📋 输入参数:")
+    debug_print(f"  🧪 溶剂: {solvent}")
+    debug_print(f"  🥽 目标容器: {target_vessel} {'(默认)' if vessel is None else '(指定)'}")
+    debug_print(f"  💧 体积: {volume} mL")
+    debug_print(f"  ⚙️ 其他参数: {kwargs}")
+    debug_print("=" * 60)
+    
+    # 添加初始日志
+    action_sequence.append(create_action_log(f"开始重置处理操作 - 容器: {target_vessel}", "🎬"))
+    action_sequence.append(create_action_log(f"使用溶剂: {solvent}", "🧪"))
+    action_sequence.append(create_action_log(f"重置体积: {volume}mL", "💧"))
+    
+    if vessel is None:
+        action_sequence.append(create_action_log("使用默认目标容器: main_reactor", "⚙️"))
+    else:
+        action_sequence.append(create_action_log(f"使用指定目标容器: {vessel}", "🎯"))
+    
+    # 1. 验证目标容器存在
+    debug_print("🔍 步骤1: 验证目标容器...")
+    action_sequence.append(create_action_log("正在验证目标容器...", "🔍"))
+    
+    if target_vessel not in G.nodes():
+        debug_print(f"❌ 目标容器 '{target_vessel}' 不存在于系统中!")
+        action_sequence.append(create_action_log(f"目标容器 '{target_vessel}' 不存在", "❌"))
+        raise ValueError(f"目标容器 '{target_vessel}' 不存在于系统中")
+    
+    debug_print(f"✅ 目标容器 '{target_vessel}' 验证通过")
+    action_sequence.append(create_action_log(f"目标容器验证通过: {target_vessel}", "✅"))
+    
+    # 2. 查找溶剂容器
+    debug_print("🔍 步骤2: 查找溶剂容器...")
+    action_sequence.append(create_action_log("正在查找溶剂容器...", "🔍"))
+    
+    try:
+        solvent_vessel = find_solvent_vessel(G, solvent)
+        debug_print(f"✅ 找到溶剂容器: {solvent_vessel}")
+        action_sequence.append(create_action_log(f"找到溶剂容器: {solvent_vessel}", "✅"))
+    except ValueError as e:
+        debug_print(f"❌ 溶剂容器查找失败: {str(e)}")
+        action_sequence.append(create_action_log(f"溶剂容器查找失败: {str(e)}", "❌"))
+        raise ValueError(f"无法找到溶剂 '{solvent}': {str(e)}")
+    
+    # 3. 验证路径存在
+    debug_print("🔍 步骤3: 验证传输路径...")
+    action_sequence.append(create_action_log("正在验证传输路径...", "🛤️"))
+    
+    try:
+        path = nx.shortest_path(G, source=solvent_vessel, target=target_vessel)
+        debug_print(f"✅ 找到路径: {' → '.join(path)}")
+        action_sequence.append(create_action_log(f"传输路径: {' → '.join(path)}", "🛤️"))
+    except nx.NetworkXNoPath:
+        debug_print(f"❌ 路径不可达: {solvent_vessel} → {target_vessel}")
+        action_sequence.append(create_action_log(f"路径不可达: {solvent_vessel} → {target_vessel}", "❌"))
+        raise ValueError(f"从溶剂容器 '{solvent_vessel}' 到目标容器 '{target_vessel}' 没有可用路径")
+    
+    # 4. 使用pump_protocol转移溶剂
+    debug_print("🔍 步骤4: 转移溶剂...")
+    action_sequence.append(create_action_log("开始溶剂转移操作...", "🚰"))
+    
+    debug_print(f"🚛 开始转移: {solvent_vessel} → {target_vessel}")
+    debug_print(f"💧 转移体积: {volume} mL")
+    action_sequence.append(create_action_log(f"转移: {solvent_vessel} → {target_vessel} ({volume}mL)", "🚛"))
+    
+    try:
+        debug_print("🔄 生成泵送协议...")
+        action_sequence.append(create_action_log("正在生成泵送协议...", "🔄"))
+        
+        pump_actions = generate_pump_protocol_with_rinsing(
+            G=G,
+            from_vessel=solvent_vessel,
+            to_vessel=target_vessel,
+            volume=volume,
+            amount="",
+            time=0.0,
+            viscous=False,
+            rinsing_solvent="",  # 重置处理不需要清洗
+            rinsing_volume=0.0,
+            rinsing_repeats=0,
+            solid=False,
+            flowrate=2.5,  # 正常流速
+            transfer_flowrate=0.5  # 正常转移流速
+        )
+        
+        action_sequence.extend(pump_actions)
+        debug_print(f"✅ 泵送协议已添加: {len(pump_actions)} 个动作")
+        action_sequence.append(create_action_log(f"泵送协议完成 ({len(pump_actions)} 个操作)", "✅"))
+        
+    except Exception as e:
+        debug_print(f"❌ 泵送协议生成失败: {str(e)}")
+        action_sequence.append(create_action_log(f"泵送协议生成失败: {str(e)}", "❌"))
+        raise ValueError(f"生成泵协议时出错: {str(e)}")
+    
+    # 5. 等待溶剂稳定
+    debug_print("🔍 步骤5: 等待溶剂稳定...")
+    action_sequence.append(create_action_log("等待溶剂稳定...", "⏳"))
+    
+    # 模拟运行时间优化
+    debug_print("⏱️ 检查模拟运行时间限制...")
+    original_wait_time = 10.0  # 原始等待时间
+    simulation_time_limit = 5.0  # 模拟运行时间限制：5秒
+    
+    final_wait_time = min(original_wait_time, simulation_time_limit)
+    
+    if original_wait_time > simulation_time_limit:
+        debug_print(f"🎮 模拟运行优化: {original_wait_time}s → {final_wait_time}s")
+        action_sequence.append(create_action_log(f"时间优化: {original_wait_time}s → {final_wait_time}s", "⚡"))
+    else:
+        debug_print(f"✅ 时间在限制内: {final_wait_time}s 保持不变")
+        action_sequence.append(create_action_log(f"等待时间: {final_wait_time}s", "⏰"))
+    
+    action_sequence.append({
+        "action_name": "wait",
+        "action_kwargs": {
+            "time": final_wait_time,
+            "description": f"等待溶剂 {solvent} 在容器 {target_vessel} 中稳定" + (f" (模拟时间)" if original_wait_time != final_wait_time else "")
+        }
+    })
+    debug_print(f"✅ 稳定等待已添加: {final_wait_time}s")
+    
+    # 显示时间调整信息
+    if original_wait_time != final_wait_time:
+        debug_print(f"🎭 模拟优化说明: 原计划 {original_wait_time}s，实际模拟 {final_wait_time}s")
+        action_sequence.append(create_action_log("应用模拟时间优化", "🎭"))
+    
+    # 总结
+    debug_print("=" * 60)
+    debug_print(f"🎉 重置处理协议生成完成!")
+    debug_print(f"📊 总结信息:")
+    debug_print(f"  📋 总动作数: {len(action_sequence)} 个")
+    debug_print(f"  🧪 溶剂: {solvent}")
+    debug_print(f"  🥽 源容器: {solvent_vessel}")
+    debug_print(f"  🥽 目标容器: {target_vessel} {'(默认)' if vessel is None else '(指定)'}")
+    debug_print(f"  💧 转移体积: {volume} mL")
+    debug_print(f"  ⏱️ 预计总时间: {(final_wait_time + 5):.0f} 秒")
+    debug_print(f"  🎯 操作结果: 已添加 {volume} mL {solvent} 到 {target_vessel}")
+    debug_print("=" * 60)
+    
+    # 添加完成日志
+    summary_msg = f"重置处理完成: {target_vessel} (使用 {volume}mL {solvent})"
+    if vessel is None:
+        summary_msg += " [默认容器]"
+    else:
+        summary_msg += " [指定容器]"
+    
+    action_sequence.append(create_action_log(summary_msg, "🎉"))
+    
+    return action_sequence
+
+# === 便捷函数 ===
+
+def reset_main_reactor(G: nx.DiGraph, solvent: str = "methanol", **kwargs) -> List[Dict[str, Any]]:
+    """重置主反应器 (默认行为)"""
+    debug_print(f"🔄 重置主反应器，使用溶剂: {solvent}")
+    return generate_reset_handling_protocol(G, solvent=solvent, vessel=None, **kwargs)
+
+def reset_custom_vessel(G: nx.DiGraph, vessel: str, solvent: str = "methanol", **kwargs) -> List[Dict[str, Any]]:
+    """重置指定容器"""
+    debug_print(f"🔄 重置指定容器: {vessel}，使用溶剂: {solvent}")
+    return generate_reset_handling_protocol(G, solvent=solvent, vessel=vessel, **kwargs)
+
+def reset_with_water(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+    """使用水重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"💧 使用水重置容器: {target}")
+    return generate_reset_handling_protocol(G, solvent="water", vessel=vessel, **kwargs)
+
+def reset_with_methanol(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+    """使用甲醇重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"🧪 使用甲醇重置容器: {target}")
+    return generate_reset_handling_protocol(G, solvent="methanol", vessel=vessel, **kwargs)
+
+def reset_with_ethanol(G: nx.DiGraph, vessel: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+    """使用乙醇重置容器"""
+    target = vessel or "main_reactor"
+    debug_print(f"🧪 使用乙醇重置容器: {target}")
+    return generate_reset_handling_protocol(G, solvent="ethanol", vessel=vessel, **kwargs)
+
+# 测试函数
+def test_reset_handling_protocol():
+    """测试重置处理协议"""
+    debug_print("=== 重置处理协议增强中文版测试 ===")
+    
+    # 测试溶剂名称
+    debug_print("🧪 测试常用溶剂名称...")
+    test_solvents = ["methanol", "ethanol", "water", "acetone", "dmso"]
+    for solvent in test_solvents:
+        debug_print(f"  🔍 测试溶剂: {solvent}")
+    
+    # 测试容器参数
+    debug_print("🥽 测试容器参数...")
+    test_cases = [
+        {"solvent": "methanol", "vessel": None, "desc": "默认容器"},
+        {"solvent": "ethanol", "vessel": "reactor_2", "desc": "指定容器"},
+        {"solvent": "water", "vessel": "flask_1", "desc": "自定义容器"}
+    ]
+    
+    for case in test_cases:
+        debug_print(f"  🧪 测试案例: {case['desc']} - {case['solvent']} -> {case['vessel'] or 'main_reactor'}")
+    
+    debug_print("✅ 测试完成")
+
+if __name__ == "__main__":
+    test_reset_handling_protocol()

unilabos/compile/run_column_protocol.py

@@ -1,102 +1,807 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
+from .utils.vessel_parser import get_vessel
+from .pump_protocol import generate_pump_protocol_with_rinsing
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[RUN_COLUMN] {message}")
+
+def parse_percentage(pct_str: str) -> float:
+    """
+    解析百分比字符串为数值
+    
+    Args:
+        pct_str: 百分比字符串（如 "40 %", "40%", "40"）
+    
+    Returns:
+        float: 百分比数值（0-100）
+    """
+    if not pct_str or not pct_str.strip():
+        return 0.0
+    
+    pct_str = pct_str.strip().lower()
+    debug_print(f"🔍 解析百分比: '{pct_str}'")
+    
+    # 移除百分号和空格
+    pct_clean = re.sub(r'[%\s]', '', pct_str)
+    
+    # 提取数字
+    match = re.search(r'([0-9]*\.?[0-9]+)', pct_clean)
+    if match:
+        value = float(match.group(1))
+        debug_print(f"✅ 百分比解析结果: {value}%")
+        return value
+    
+    debug_print(f"⚠️ 无法解析百分比: '{pct_str}'，返回0.0")
+    return 0.0
+
+def parse_ratio(ratio_str: str) -> tuple:
+    """
+    解析比例字符串为两个数值
+    
+    Args:
+        ratio_str: 比例字符串（如 "5:95", "1:1", "40:60"）
+    
+    Returns:
+        tuple: (ratio1, ratio2) 两个比例值
+    """
+    if not ratio_str or not ratio_str.strip():
+        return (50.0, 50.0)  # 默认1:1
+    
+    ratio_str = ratio_str.strip()
+    debug_print(f"🔍 解析比例: '{ratio_str}'")
+    
+    # 支持多种分隔符：: / -
+    if ':' in ratio_str:
+        parts = ratio_str.split(':')
+    elif '/' in ratio_str:
+        parts = ratio_str.split('/')
+    elif '-' in ratio_str:
+        parts = ratio_str.split('-')
+    elif 'to' in ratio_str.lower():
+        parts = ratio_str.lower().split('to')
+    else:
+        debug_print(f"⚠️ 无法解析比例格式: '{ratio_str}'，使用默认1:1")
+        return (50.0, 50.0)
+    
+    if len(parts) >= 2:
+        try:
+            ratio1 = float(parts[0].strip())
+            ratio2 = float(parts[1].strip())
+            total = ratio1 + ratio2
+            
+            # 转换为百分比
+            pct1 = (ratio1 / total) * 100
+            pct2 = (ratio2 / total) * 100
+            
+            debug_print(f"✅ 比例解析结果: {ratio1}:{ratio2} -> {pct1:.1f}%:{pct2:.1f}%")
+            return (pct1, pct2)
+        except ValueError as e:
+            debug_print(f"⚠️ 比例数值转换失败: {str(e)}")
+    
+    debug_print(f"⚠️ 比例解析失败，使用默认1:1")
+    return (50.0, 50.0)
+
+def parse_rf_value(rf_str: str) -> float:
+    """
+    解析Rf值字符串
+    
+    Args:
+        rf_str: Rf值字符串（如 "0.3", "0.45", "?"）
+    
+    Returns:
+        float: Rf值（0-1）
+    """
+    if not rf_str or not rf_str.strip():
+        return 0.3  # 默认Rf值
+    
+    rf_str = rf_str.strip().lower()
+    debug_print(f"🔍 解析Rf值: '{rf_str}'")
+    
+    # 处理未知Rf值
+    if rf_str in ['?', 'unknown', 'tbd', 'to be determined']:
+        default_rf = 0.3
+        debug_print(f"❓ 检测到未知Rf值，使用默认值: {default_rf}")
+        return default_rf
+    
+    # 提取数字
+    match = re.search(r'([0-9]*\.?[0-9]+)', rf_str)
+    if match:
+        value = float(match.group(1))
+        # 确保Rf值在0-1范围内
+        if value > 1.0:
+            value = value / 100.0  # 可能是百分比形式
+        value = max(0.0, min(1.0, value))  # 限制在0-1范围
+        debug_print(f"✅ Rf值解析结果: {value}")
+        return value
+    
+    debug_print(f"⚠️ 无法解析Rf值: '{rf_str}'，使用默认值0.3")
+    return 0.3
+
+def find_column_device(G: nx.DiGraph) -> str:
+    """查找柱层析设备"""
+    debug_print("🔍 查找柱层析设备...")
+    
+    # 查找虚拟柱设备
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'virtual_column' in node_class.lower() or 'column' in node_class.lower():
+            debug_print(f"🎉 找到柱层析设备: {node} ✨")
+            return node
+    
+    # 如果没有找到，尝试创建虚拟设备名称
+    possible_names = ['column_1', 'virtual_column_1', 'chromatography_column_1']
+    for name in possible_names:
+        if name in G.nodes():
+            debug_print(f"🎉 找到柱设备: {name} ✨")
+            return name
+    
+    debug_print("⚠️ 未找到柱层析设备，将使用pump protocol直接转移")
+    return ""
+
+def find_column_vessel(G: nx.DiGraph, column: str) -> str:
+    """查找柱容器"""
+    debug_print(f"🔍 查找柱容器: '{column}'")
+    
+    # 直接检查column参数是否是容器
+    if column in G.nodes():
+        node_type = G.nodes[column].get('type', '')
+        if node_type == 'container':
+            debug_print(f"🎉 找到柱容器: {column} ✨")
+            return column
+    
+    # 尝试常见的命名规则
+    possible_names = [
+        f"column_{column}",
+        f"{column}_column", 
+        f"vessel_{column}",
+        f"{column}_vessel",
+        "column_vessel",
+        "chromatography_column",
+        "silica_column",
+        "preparative_column",
+        "column"
+    ]
+    
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            node_type = G.nodes[vessel_name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"🎉 找到柱容器: {vessel_name} ✨")
+                return vessel_name
+    
+    debug_print(f"⚠️ 未找到柱容器，将直接在源容器中进行分离")
+    return ""
+
+def find_solvent_vessel(G: nx.DiGraph, solvent: str) -> str:
+    """查找溶剂容器 - 增强版"""
+    if not solvent or not solvent.strip():
+        return ""
+    
+    solvent = solvent.strip().replace(' ', '_').lower()
+    debug_print(f"🔍 查找溶剂容器: '{solvent}'")
+    
+    # 🔧 方法1：直接搜索 data.reagent_name
+    for node in G.nodes():
+        node_data = G.nodes[node].get('data', {})
+        node_type = G.nodes[node].get('type', '')
+        
+        # 只搜索容器类型的节点
+        if node_type == 'container':
+            reagent_name = node_data.get('reagent_name', '').lower()
+            reagent_config = G.nodes[node].get('config', {}).get('reagent', '').lower()
+            
+            # 检查 data.reagent_name 和 config.reagent
+            if reagent_name == solvent or reagent_config == solvent:
+                debug_print(f"🎉 通过reagent_name找到溶剂容器: {node} (reagent: {reagent_name or reagent_config}) ✨")
+                return node
+            
+            # 模糊匹配 reagent_name
+            if solvent in reagent_name or reagent_name in solvent:
+                debug_print(f"🎉 通过reagent_name模糊匹配到溶剂容器: {node} (reagent: {reagent_name}) ✨")
+                return node
+            
+            if solvent in reagent_config or reagent_config in solvent:
+                debug_print(f"🎉 通过config.reagent模糊匹配到溶剂容器: {node} (reagent: {reagent_config}) ✨")
+                return node
+    
+    # 🔧 方法2：常见的溶剂容器命名规则
+    possible_names = [
+        f"flask_{solvent}",
+        f"bottle_{solvent}",
+        f"reagent_{solvent}",
+        f"{solvent}_bottle",
+        f"{solvent}_flask",
+        f"solvent_{solvent}",
+        f"reagent_bottle_{solvent}"
+    ]
+    
+    for vessel_name in possible_names:
+        if vessel_name in G.nodes():
+            node_type = G.nodes[vessel_name].get('type', '')
+            if node_type == 'container':
+                debug_print(f"🎉 通过命名规则找到溶剂容器: {vessel_name} ✨")
+                return vessel_name
+    
+    # 🔧 方法3：节点名称模糊匹配
+    for node in G.nodes():
+        node_type = G.nodes[node].get('type', '')
+        if node_type == 'container':
+            if ('flask_' in node or 'bottle_' in node or 'reagent_' in node) and solvent in node.lower():
+                debug_print(f"🎉 通过节点名称模糊匹配到溶剂容器: {node} ✨")
+                return node
+    
+    # 🔧 方法4：特殊溶剂名称映射
+    solvent_mapping = {
+        'dmf': ['dmf', 'dimethylformamide', 'n,n-dimethylformamide'],
+        'ethyl_acetate': ['ethyl_acetate', 'ethylacetate', 'etoac', 'ea'],
+        'hexane': ['hexane', 'hexanes', 'n-hexane'],
+        'methanol': ['methanol', 'meoh', 'ch3oh'],
+        'water': ['water', 'h2o', 'distilled_water'],
+        'acetone': ['acetone', 'ch3coch3', '2-propanone'],
+        'dichloromethane': ['dichloromethane', 'dcm', 'ch2cl2', 'methylene_chloride'],
+        'chloroform': ['chloroform', 'chcl3', 'trichloromethane']
+    }
+    
+    # 查找映射的同义词
+    for canonical_name, synonyms in solvent_mapping.items():
+        if solvent in synonyms:
+            debug_print(f"🔍 检测到溶剂同义词: '{solvent}' -> '{canonical_name}'")
+            return find_solvent_vessel(G, canonical_name)  # 递归搜索
+    
+    debug_print(f"⚠️ 未找到溶剂 '{solvent}' 的容器")
+    return ""
+
+def get_vessel_liquid_volume(vessel: dict) -> float:
+    """
+    获取容器中的液体体积 - 支持vessel字典
+    
+    Args:
+        vessel: 容器字典
+        
+    Returns:
+        float: 液体体积（mL）
+    """
+    if not vessel or "data" not in vessel:
+        debug_print(f"⚠️ 容器数据为空，返回 0.0mL")
+        return 0.0
+    
+    vessel_data = vessel["data"]
+    vessel_id = vessel.get("id", "unknown")
+    
+    debug_print(f"🔍 读取容器 '{vessel_id}' 体积数据: {vessel_data}")
+    
+    # 检查liquid_volume字段
+    if "liquid_volume" in vessel_data:
+        liquid_volume = vessel_data["liquid_volume"]
+        
+        # 处理列表格式
+        if isinstance(liquid_volume, list):
+            if len(liquid_volume) > 0:
+                volume = liquid_volume[0]
+                if isinstance(volume, (int, float)):
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (列表格式)")
+                    return float(volume)
+        
+        # 处理直接数值格式
+        elif isinstance(liquid_volume, (int, float)):
+            debug_print(f"✅ 容器 '{vessel_id}' 体积: {liquid_volume}mL (数值格式)")
+            return float(liquid_volume)
+    
+    # 检查其他可能的体积字段
+    volume_keys = ['current_volume', 'total_volume', 'volume']
+    for key in volume_keys:
+        if key in vessel_data:
+            try:
+                volume = float(vessel_data[key])
+                if volume > 0:
+                    debug_print(f"✅ 容器 '{vessel_id}' 体积: {volume}mL (字段: {key})")
+                    return volume
+            except (ValueError, TypeError):
+                continue
+    
+    debug_print(f"⚠️ 无法获取容器 '{vessel_id}' 的体积，返回默认值 50.0mL")
+    return 50.0
+
+def update_vessel_volume(vessel: dict, G: nx.DiGraph, new_volume: float, description: str = "") -> None:
+    """
+    更新容器体积（同时更新vessel字典和图节点）
+    
+    Args:
+        vessel: 容器字典
+        G: 网络图
+        new_volume: 新体积
+        description: 更新描述
+    """
+    vessel_id = vessel.get("id", "unknown")
+    
+    if description:
+        debug_print(f"🔧 更新容器体积 - {description}")
+    
+    # 更新vessel字典中的体积
+    if "data" in vessel:
+        if "liquid_volume" in vessel["data"]:
+            current_volume = vessel["data"]["liquid_volume"]
+            if isinstance(current_volume, list):
+                if len(current_volume) > 0:
+                    vessel["data"]["liquid_volume"][0] = new_volume
+                else:
+                    vessel["data"]["liquid_volume"] = [new_volume]
+            else:
+                vessel["data"]["liquid_volume"] = new_volume
+        else:
+            vessel["data"]["liquid_volume"] = new_volume
+    else:
+        vessel["data"] = {"liquid_volume": new_volume}
+    
+    # 同时更新图中的容器数据
+    if vessel_id in G.nodes():
+        if 'data' not in G.nodes[vessel_id]:
+            G.nodes[vessel_id]['data'] = {}
+        
+        vessel_node_data = G.nodes[vessel_id]['data']
+        current_node_volume = vessel_node_data.get('liquid_volume', 0.0)
+        
+        if isinstance(current_node_volume, list):
+            if len(current_node_volume) > 0:
+                G.nodes[vessel_id]['data']['liquid_volume'][0] = new_volume
+            else:
+                G.nodes[vessel_id]['data']['liquid_volume'] = [new_volume]
+        else:
+            G.nodes[vessel_id]['data']['liquid_volume'] = new_volume
+    
+    debug_print(f"📊 容器 '{vessel_id}' 体积已更新为: {new_volume:.2f}mL")
+
+def calculate_solvent_volumes(total_volume: float, pct1: float, pct2: float) -> tuple:
+    """根据百分比计算溶剂体积"""
+    volume1 = (total_volume * pct1) / 100.0
+    volume2 = (total_volume * pct2) / 100.0
+    
+    debug_print(f"🧮 溶剂体积计算: 总体积{total_volume}mL")
+    debug_print(f"  - 溶剂1: {pct1}% = {volume1}mL")
+    debug_print(f"  - 溶剂2: {pct2}% = {volume2}mL")
+    
+    return (volume1, volume2)
 
 def generate_run_column_protocol(
     G: nx.DiGraph,
-    from_vessel: str,
-    to_vessel: str,
-    column: str
+    from_vessel: dict,  # 🔧 修改：从字符串改为字典类型
+    to_vessel: dict,    # 🔧 修改：从字符串改为字典类型
+    column: str,
+    rf: str = "",
+    pct1: str = "",
+    pct2: str = "",
+    solvent1: str = "",
+    solvent2: str = "",
+    ratio: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
     """
-    生成柱层析分离的协议序列
+    生成柱层析分离的协议序列 - 支持vessel字典和体积运算
     
     Args:
-        G: 有向图，节点为设备和容器
-        from_vessel: 源容器的名称，即样品起始所在的容器
-        to_vessel: 目标容器的名称，分离后的样品要到达的容器
-        column: 所使用的柱子的名称
+        G: 有向图，节点为设备和容器，边为流体管道
+        from_vessel: 源容器字典（从XDL传入）
+        to_vessel: 目标容器字典（从XDL传入）
+        column: 所使用的柱子的名称（必需）
+        rf: Rf值（可选，支持 "?" 表示未知）
+        pct1: 第一种溶剂百分比（如 "40 %"，可选）
+        pct2: 第二种溶剂百分比（如 "50 %"，可选）
+        solvent1: 第一种溶剂名称（可选）
+        solvent2: 第二种溶剂名称（可选）
+        ratio: 溶剂比例（如 "5:95"，可选，优先级高于pct1/pct2）
+        **kwargs: 其他可选参数
     
     Returns:
         List[Dict[str, Any]]: 柱层析分离操作的动作序列
-    
-    Raises:
-        ValueError: 当找不到必要的设备时抛出异常
-    
-    Examples:
-        run_column_protocol = generate_run_column_protocol(G, "reactor", "collection_flask", "silica_column")
     """
+    
+    # 🔧 核心修改：从字典中提取容器ID
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+
+    debug_print("🏛️" * 20)
+    debug_print("🚀 开始生成柱层析协议（支持vessel字典和体积运算）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 from_vessel: {from_vessel} (ID: {from_vessel_id})")
+    debug_print(f"  🥽 to_vessel: {to_vessel} (ID: {to_vessel_id})")
+    debug_print(f"  🏛️ column: '{column}'")
+    debug_print(f"  📊 rf: '{rf}'")
+    debug_print(f"  🧪 溶剂配比: pct1='{pct1}', pct2='{pct2}', ratio='{ratio}'")
+    debug_print(f"  🧪 溶剂名称: solvent1='{solvent1}', solvent2='{solvent2}'")
+    debug_print("🏛️" * 20)
+    
     action_sequence = []
     
-    # 验证容器是否存在
-    if from_vessel not in G.nodes():
-        raise ValueError(f"源容器 {from_vessel} 不存在于图中")
+    # 🔧 新增：记录柱层析前的容器状态
+    debug_print("🔍 记录柱层析前容器状态...")
+    original_from_volume = get_vessel_liquid_volume(from_vessel)
+    original_to_volume = get_vessel_liquid_volume(to_vessel)
     
-    if to_vessel not in G.nodes():
-        raise ValueError(f"目标容器 {to_vessel} 不存在于图中")
+    debug_print(f"📊 柱层析前状态:")
+    debug_print(f"  - 源容器 {from_vessel_id}: {original_from_volume:.2f}mL")
+    debug_print(f"  - 目标容器 {to_vessel_id}: {original_to_volume:.2f}mL")
     
-    # 查找转移泵设备（用于样品转移）
-    pump_nodes = [node for node in G.nodes() 
-                  if G.nodes[node].get('class') == 'virtual_transfer_pump']
+    # === 参数验证 ===
+    debug_print("📍 步骤1: 参数验证...")
     
-    if not pump_nodes:
-        raise ValueError("没有找到可用的转移泵设备")
+    if not from_vessel_id:  # 🔧 使用 from_vessel_id
+        raise ValueError("from_vessel 参数不能为空")
+    if not to_vessel_id:    # 🔧 使用 to_vessel_id
+        raise ValueError("to_vessel 参数不能为空")
+    if not column:
+        raise ValueError("column 参数不能为空")
     
-    pump_id = pump_nodes[0]
+    if from_vessel_id not in G.nodes():  # 🔧 使用 from_vessel_id
+        raise ValueError(f"源容器 '{from_vessel_id}' 不存在于系统中")
+    if to_vessel_id not in G.nodes():    # 🔧 使用 to_vessel_id
+        raise ValueError(f"目标容器 '{to_vessel_id}' 不存在于系统中")
+    
+    debug_print("✅ 基本参数验证通过")
+    
+    # === 参数解析 ===
+    debug_print("📍 步骤2: 参数解析...")
+    
+    # 解析Rf值
+    final_rf = parse_rf_value(rf)
+    debug_print(f"🎯 最终Rf值: {final_rf}")
+    
+    # 解析溶剂比例（ratio优先级高于pct1/pct2）
+    if ratio and ratio.strip():
+        final_pct1, final_pct2 = parse_ratio(ratio)
+        debug_print(f"📊 使用ratio参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
+    else:
+        final_pct1 = parse_percentage(pct1) if pct1 else 50.0
+        final_pct2 = parse_percentage(pct2) if pct2 else 50.0
+        
+        # 如果百分比和不是100%，进行归一化
+        total_pct = final_pct1 + final_pct2
+        if total_pct == 0:
+            final_pct1, final_pct2 = 50.0, 50.0
+        elif total_pct != 100.0:
+            final_pct1 = (final_pct1 / total_pct) * 100
+            final_pct2 = (final_pct2 / total_pct) * 100
+        
+        debug_print(f"📊 使用百分比参数: {final_pct1:.1f}% : {final_pct2:.1f}%")
+    
+    # 设置默认溶剂（如果未指定）
+    final_solvent1 = solvent1.strip() if solvent1 else "ethyl_acetate"
+    final_solvent2 = solvent2.strip() if solvent2 else "hexane"
+    
+    debug_print(f"🧪 最终溶剂: {final_solvent1} : {final_solvent2}")
+    
+    # === 查找设备和容器 ===
+    debug_print("📍 步骤3: 查找设备和容器...")
     
     # 查找柱层析设备
-    column_nodes = [node for node in G.nodes() 
-                   if G.nodes[node].get('class') == 'virtual_column']
+    column_device_id = find_column_device(G)
     
-    if not column_nodes:
-        raise ValueError("没有找到可用的柱层析设备")
+    # 查找柱容器
+    column_vessel = find_column_vessel(G, column)
     
-    column_id = column_nodes[0]
+    # 查找溶剂容器
+    solvent1_vessel = find_solvent_vessel(G, final_solvent1)
+    solvent2_vessel = find_solvent_vessel(G, final_solvent2)
     
-    # 步骤1：将样品从源容器转移到柱子上
-    action_sequence.append({
-        "device_id": pump_id,
-        "action_name": "transfer",
-        "action_kwargs": {
-            "from_vessel": from_vessel,
-            "to_vessel": column_id,  # 将样品转移到柱子设备
-            "volume": 0.0,  # 转移所有液体，体积由系统确定
-            "amount": f"样品上柱 - 使用 {column}",
-            "time": 0.0,
-            "viscous": False,
-            "rinsing_solvent": "",
-            "rinsing_volume": 0.0,
-            "rinsing_repeats": 0,
-            "solid": False
-        }
-    })
+    debug_print(f"🔧 设备映射:")
+    debug_print(f"  - 柱设备: '{column_device_id}'")
+    debug_print(f"  - 柱容器: '{column_vessel}'")
+    debug_print(f"  - 溶剂1容器: '{solvent1_vessel}'")
+    debug_print(f"  - 溶剂2容器: '{solvent2_vessel}'")
     
-    # 步骤2：运行柱层析分离
-    action_sequence.append({
-        "device_id": column_id,
-        "action_name": "run_column",
-        "action_kwargs": {
-            "from_vessel": from_vessel,
-            "to_vessel": to_vessel,
-            "column": column
-        }
-    })
+    # === 获取源容器体积 ===
+    debug_print("📍 步骤4: 获取源容器体积...")
     
-    # 步骤3：将分离后的产物从柱子转移到目标容器
-    action_sequence.append({
-        "device_id": pump_id,
-        "action_name": "transfer",
-        "action_kwargs": {
-            "from_vessel": column_id,  # 从柱子设备转移
-            "to_vessel": to_vessel,
-            "volume": 0.0,  # 转移所有液体，体积由系统确定
-            "amount": f"收集分离产物 - 来自 {column}",
-            "time": 0.0,
-            "viscous": False,
-            "rinsing_solvent": "",
-            "rinsing_volume": 0.0,
-            "rinsing_repeats": 0,
-            "solid": False
-        }
-    })
+    source_volume = original_from_volume
+    if source_volume <= 0:
+        source_volume = 50.0  # 默认体积
+        debug_print(f"⚠️ 无法获取源容器体积，使用默认值: {source_volume}mL")
+    else:
+        debug_print(f"✅ 源容器体积: {source_volume}mL")
+    
+    # === 计算溶剂体积 ===
+    debug_print("📍 步骤5: 计算溶剂体积...")
+    
+    # 洗脱溶剂通常是样品体积的2-5倍
+    total_elution_volume = source_volume * 3.0
+    solvent1_volume, solvent2_volume = calculate_solvent_volumes(
+        total_elution_volume, final_pct1, final_pct2
+    )
+    
+    # === 执行柱层析流程 ===
+    debug_print("📍 步骤6: 执行柱层析流程...")
+    
+    # 🔧 新增：体积变化跟踪变量
+    current_from_volume = source_volume
+    current_to_volume = original_to_volume
+    current_column_volume = 0.0
+    
+    try:
+        # 步骤6.1: 样品上柱（如果有独立的柱容器）
+        if column_vessel and column_vessel != from_vessel_id:  # 🔧 使用 from_vessel_id
+            debug_print(f"📍 6.1: 样品上柱 - {source_volume}mL 从 {from_vessel_id} 到 {column_vessel}")
+            
+            try:
+                sample_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=from_vessel_id,  # 🔧 使用 from_vessel_id
+                    to_vessel=column_vessel,
+                    volume=source_volume,
+                    flowrate=1.0,  # 慢速上柱
+                    transfer_flowrate=0.5,
+                    rinsing_solvent="",  # 暂不冲洗
+                    rinsing_volume=0.0,
+                    rinsing_repeats=0
+                )
+                action_sequence.extend(sample_transfer_actions)
+                debug_print(f"✅ 样品上柱完成，添加了 {len(sample_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 样品转移到柱上
+                current_from_volume = 0.0  # 源容器体积变为0
+                current_column_volume = source_volume  # 柱容器体积增加
+                
+                update_vessel_volume(from_vessel, G, current_from_volume, "样品上柱后，源容器清空")
+                
+                # 如果柱容器在图中，也更新其体积
+                if column_vessel in G.nodes():
+                    if 'data' not in G.nodes[column_vessel]:
+                        G.nodes[column_vessel]['data'] = {}
+                    G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
+                    debug_print(f"📊 柱容器 '{column_vessel}' 体积更新为: {current_column_volume:.2f}mL")
+                
+            except Exception as e:
+                debug_print(f"⚠️ 样品上柱失败: {str(e)}")
+        
+        # 步骤6.2: 添加洗脱溶剂1（如果有溶剂容器）
+        if solvent1_vessel and solvent1_volume > 0:
+            debug_print(f"📍 6.2: 添加洗脱溶剂1 - {solvent1_volume:.1f}mL {final_solvent1}")
+            
+            try:
+                target_vessel = column_vessel if column_vessel else from_vessel_id  # 🔧 使用 from_vessel_id
+                solvent1_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=solvent1_vessel,
+                    to_vessel=target_vessel,
+                    volume=solvent1_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(solvent1_transfer_actions)
+                debug_print(f"✅ 溶剂1添加完成，添加了 {len(solvent1_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 添加溶剂1
+                if target_vessel == column_vessel:
+                    current_column_volume += solvent1_volume
+                    if column_vessel in G.nodes():
+                        G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
+                        debug_print(f"📊 柱容器体积增加: +{solvent1_volume:.2f}mL = {current_column_volume:.2f}mL")
+                elif target_vessel == from_vessel_id:
+                    current_from_volume += solvent1_volume
+                    update_vessel_volume(from_vessel, G, current_from_volume, "添加溶剂1后")
+                
+            except Exception as e:
+                debug_print(f"⚠️ 溶剂1添加失败: {str(e)}")
+        
+        # 步骤6.3: 添加洗脱溶剂2（如果有溶剂容器）
+        if solvent2_vessel and solvent2_volume > 0:
+            debug_print(f"📍 6.3: 添加洗脱溶剂2 - {solvent2_volume:.1f}mL {final_solvent2}")
+            
+            try:
+                target_vessel = column_vessel if column_vessel else from_vessel_id  # 🔧 使用 from_vessel_id
+                solvent2_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=solvent2_vessel,
+                    to_vessel=target_vessel,
+                    volume=solvent2_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(solvent2_transfer_actions)
+                debug_print(f"✅ 溶剂2添加完成，添加了 {len(solvent2_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 添加溶剂2
+                if target_vessel == column_vessel:
+                    current_column_volume += solvent2_volume
+                    if column_vessel in G.nodes():
+                        G.nodes[column_vessel]['data']['liquid_volume'] = current_column_volume
+                        debug_print(f"📊 柱容器体积增加: +{solvent2_volume:.2f}mL = {current_column_volume:.2f}mL")
+                elif target_vessel == from_vessel_id:
+                    current_from_volume += solvent2_volume
+                    update_vessel_volume(from_vessel, G, current_from_volume, "添加溶剂2后")
+                
+            except Exception as e:
+                debug_print(f"⚠️ 溶剂2添加失败: {str(e)}")
+        
+        # 步骤6.4: 使用柱层析设备执行分离（如果有设备）
+        if column_device_id:
+            debug_print(f"📍 6.4: 使用柱层析设备执行分离")
+            
+            column_separation_action = {
+                "device_id": column_device_id,
+                "action_name": "run_column",
+                "action_kwargs": {
+                    "from_vessel": from_vessel_id,  # 🔧 使用 from_vessel_id
+                    "to_vessel": to_vessel_id,      # 🔧 使用 to_vessel_id
+                    "column": column,
+                    "rf": rf,
+                    "pct1": pct1,
+                    "pct2": pct2,
+                    "solvent1": solvent1,
+                    "solvent2": solvent2,
+                    "ratio": ratio
+                }
+            }
+            action_sequence.append(column_separation_action)
+            debug_print(f"✅ 柱层析设备动作已添加")
+            
+            # 等待分离完成
+            separation_time = max(30, min(120, int(total_elution_volume / 2)))  # 30-120秒，基于体积
+            action_sequence.append({
+                "action_name": "wait",
+                "action_kwargs": {"time": separation_time}
+            })
+            debug_print(f"✅ 等待分离完成: {separation_time}秒")
+        
+        # 步骤6.5: 产物收集（从柱容器到目标容器）
+        if column_vessel and column_vessel != to_vessel_id:  # 🔧 使用 to_vessel_id
+            debug_print(f"📍 6.5: 产物收集 - 从 {column_vessel} 到 {to_vessel_id}")
+            
+            try:
+                # 估算产物体积（原始样品体积的70-90%，收率考虑）
+                product_volume = source_volume * 0.8
+                
+                product_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=column_vessel,
+                    to_vessel=to_vessel_id,  # 🔧 使用 to_vessel_id
+                    volume=product_volume,
+                    flowrate=1.5,
+                    transfer_flowrate=0.8
+                )
+                action_sequence.extend(product_transfer_actions)
+                debug_print(f"✅ 产物收集完成，添加了 {len(product_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 产物收集到目标容器
+                current_to_volume += product_volume
+                current_column_volume -= product_volume  # 柱容器体积减少
+                
+                update_vessel_volume(to_vessel, G, current_to_volume, "产物收集后")
+                
+                # 更新柱容器体积
+                if column_vessel in G.nodes():
+                    G.nodes[column_vessel]['data']['liquid_volume'] = max(0.0, current_column_volume)
+                    debug_print(f"📊 柱容器体积减少: -{product_volume:.2f}mL = {current_column_volume:.2f}mL")
+                
+            except Exception as e:
+                debug_print(f"⚠️ 产物收集失败: {str(e)}")
+        
+        # 步骤6.6: 如果没有独立的柱设备和容器，执行简化的直接转移
+        if not column_device_id and not column_vessel:
+            debug_print(f"📍 6.6: 简化模式 - 直接转移 {source_volume}mL 从 {from_vessel_id} 到 {to_vessel_id}")
+            
+            try:
+                direct_transfer_actions = generate_pump_protocol_with_rinsing(
+                    G=G,
+                    from_vessel=from_vessel_id,  # 🔧 使用 from_vessel_id
+                    to_vessel=to_vessel_id,      # 🔧 使用 to_vessel_id
+                    volume=source_volume,
+                    flowrate=2.0,
+                    transfer_flowrate=1.0
+                )
+                action_sequence.extend(direct_transfer_actions)
+                debug_print(f"✅ 直接转移完成，添加了 {len(direct_transfer_actions)} 个动作")
+                
+                # 🔧 新增：更新体积 - 直接转移
+                current_from_volume = 0.0  # 源容器清空
+                current_to_volume += source_volume  # 目标容器增加
+                
+                update_vessel_volume(from_vessel, G, current_from_volume, "直接转移后，源容器清空")
+                update_vessel_volume(to_vessel, G, current_to_volume, "直接转移后，目标容器增加")
+                
+            except Exception as e:
+                debug_print(f"⚠️ 直接转移失败: {str(e)}")
+        
+    except Exception as e:
+        debug_print(f"❌ 协议生成失败: {str(e)} 😭")
+        
+        # 不添加不确定的动作，直接让action_sequence保持为空列表
+        # action_sequence 已经在函数开始时初始化为 []
+    
+    # 确保至少有一个有效的动作，如果完全失败就返回空列表
+    if not action_sequence:
+        debug_print("⚠️ 没有生成任何有效动作")
+        # 可以选择返回空列表或添加一个基本的等待动作
+        action_sequence.append({
+            "action_name": "wait",
+            "action_kwargs": {
+                "time": 1.0,
+                "description": "柱层析协议执行完成"
+            }
+        })
+    
+    # 🔧 新增：柱层析完成后的最终状态报告
+    final_from_volume = get_vessel_liquid_volume(from_vessel)
+    final_to_volume = get_vessel_liquid_volume(to_vessel)
+    
+    # 🎊 总结
+    debug_print("🏛️" * 20)
+    debug_print(f"🎉 柱层析协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 路径: {from_vessel_id} → {to_vessel_id}")
+    debug_print(f"🏛️ 柱子: {column}")
+    debug_print(f"🧪 溶剂: {final_solvent1}:{final_solvent2} = {final_pct1:.1f}%:{final_pct2:.1f}%")
+    debug_print(f"📊 体积变化统计:")
+    debug_print(f"  源容器 {from_vessel_id}:")
+    debug_print(f"    - 柱层析前: {original_from_volume:.2f}mL")
+    debug_print(f"    - 柱层析后: {final_from_volume:.2f}mL")
+    debug_print(f"  目标容器 {to_vessel_id}:")
+    debug_print(f"    - 柱层析前: {original_to_volume:.2f}mL")
+    debug_print(f"    - 柱层析后: {final_to_volume:.2f}mL")
+    debug_print(f"    - 收集体积: {final_to_volume - original_to_volume:.2f}mL")
+    debug_print(f"⏱️ 预计总时间: {len(action_sequence) * 5:.0f} 秒 ⌛")
+    debug_print("🏛️" * 20)
     
     return action_sequence
+
+# 🔧 新增：便捷函数
+def generate_ethyl_acetate_hexane_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                                 column: str, ratio: str = "30:70") -> List[Dict[str, Any]]:
+    """乙酸乙酯-己烷柱层析（常用组合）"""
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
+    debug_print(f"🧪⛽ 乙酸乙酯-己烷柱层析: {from_vessel_id} → {to_vessel_id} @ {ratio}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
+                                      solvent1="ethyl_acetate", solvent2="hexane", ratio=ratio)
+
+def generate_methanol_dcm_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                        column: str, ratio: str = "5:95") -> List[Dict[str, Any]]:
+    """甲醇-二氯甲烷柱层析"""
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
+    debug_print(f"🧪🧪 甲醇-DCM柱层析: {from_vessel_id} → {to_vessel_id} @ {ratio}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
+                                      solvent1="methanol", solvent2="dichloromethane", ratio=ratio)
+
+def generate_gradient_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                    column: str, start_ratio: str = "10:90", 
+                                    end_ratio: str = "50:50") -> List[Dict[str, Any]]:
+    """梯度洗脱柱层析（中等比例）"""
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"📈 梯度柱层析: {from_vessel_id} → {to_vessel_id} ({start_ratio} → {end_ratio})")
+    # 使用中间比例作为近似
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, ratio="30:70")
+
+def generate_polar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                 column: str) -> List[Dict[str, Any]]:
+    """极性化合物柱层析（高极性溶剂比例）"""
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"⚡ 极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
+                                      solvent1="ethyl_acetate", solvent2="hexane", ratio="70:30")
+
+def generate_nonpolar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
+                                    column: str) -> List[Dict[str, Any]]:
+    """非极性化合物柱层析（低极性溶剂比例）"""
+    from_vessel_id, _ = get_vessel(from_vessel)
+    to_vessel_id, _ = get_vessel(to_vessel)
+    debug_print(f"🛢️ 非极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
+    return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
+                                      solvent1="ethyl_acetate", solvent2="hexane", ratio="5:95")
+
+# 测试函数
+def test_run_column_protocol():
+    """测试柱层析协议"""
+    debug_print("🧪 === RUN COLUMN PROTOCOL 测试 === ✨")
+    debug_print("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_run_column_protocol()

unilabos/compile/stir_protocol.py

@@ -1,137 +1,478 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union
 import networkx as nx
+import logging
+import re
+
+from .utils.unit_parser import parse_time_input
+
+logger = logging.getLogger(__name__)
+
+def debug_print(message):
+    """调试输出"""
+    logger.info(f"[STIR] {message}")
+
+
+def find_connected_stirrer(G: nx.DiGraph, vessel: str = None) -> str:
+    """查找与指定容器相连的搅拌设备"""
+    debug_print(f"🔍 查找搅拌设备，目标容器: {vessel} 🥽")
+    
+    # 🔧 查找所有搅拌设备
+    stirrer_nodes = []
+    for node in G.nodes():
+        node_data = G.nodes[node]
+        node_class = node_data.get('class', '') or ''
+        
+        if 'stirrer' in node_class.lower() or 'virtual_stirrer' in node_class:
+            stirrer_nodes.append(node)
+            debug_print(f"🎉 找到搅拌设备: {node} 🌪️")
+    
+    # 🔗 检查连接
+    if vessel and stirrer_nodes:
+        for stirrer in stirrer_nodes:
+            if G.has_edge(stirrer, vessel) or G.has_edge(vessel, stirrer):
+                debug_print(f"✅ 搅拌设备 '{stirrer}' 与容器 '{vessel}' 相连 🔗")
+                return stirrer
+    
+    # 🎯 使用第一个可用设备
+    if stirrer_nodes:
+        selected = stirrer_nodes[0]
+        debug_print(f"🔧 使用第一个搅拌设备: {selected} 🌪️")
+        return selected
+    
+    # 🆘 默认设备
+    debug_print("⚠️ 未找到搅拌设备，使用默认设备 🌪️")
+    return "stirrer_1"
+
+def validate_and_fix_params(stir_time: float, stir_speed: float, settling_time: float) -> tuple:
+    """验证和修正参数"""
+    # ⏰ 搅拌时间验证
+    if stir_time < 0:
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 无效，修正为 100s 🕐")
+        stir_time = 100.0
+    elif stir_time > 100:  # 限制为100s
+        debug_print(f"⚠️ 搅拌时间 {stir_time}s 过长，仿真运行时，修正为 100s 🕐")
+        stir_time = 100.0
+    else:
+        debug_print(f"✅ 搅拌时间 {stir_time}s ({stir_time/60:.1f}分钟) 有效 ⏰")
+    
+    # 🌪️ 搅拌速度验证
+    if stir_speed < 10.0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度 {stir_speed} RPM 超出范围，修正为 300 RPM 🌪️")
+        stir_speed = 300.0
+    else:
+        debug_print(f"✅ 搅拌速度 {stir_speed} RPM 在正常范围内 🌪️")
+    
+    # ⏱️ 沉降时间验证
+    if settling_time < 0 or settling_time > 600:  # 限制为10分钟
+        debug_print(f"⚠️ 沉降时间 {settling_time}s 超出范围，修正为 60s ⏱️")
+        settling_time = 60.0
+    else:
+        debug_print(f"✅ 沉降时间 {settling_time}s 在正常范围内 ⏱️")
+    
+    return stir_time, stir_speed, settling_time
+
+def extract_vessel_id(vessel: Union[str, dict]) -> str:
+    """
+    从vessel参数中提取vessel_id
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: vessel_id
+    """
+    if isinstance(vessel, dict):
+        vessel_id = list(vessel.values())[0].get("id", "")
+        debug_print(f"🔧 从vessel字典提取ID: {vessel_id}")
+        return vessel_id
+    elif isinstance(vessel, str):
+        debug_print(f"🔧 vessel参数为字符串: {vessel}")
+        return vessel
+    else:
+        debug_print(f"⚠️ 无效的vessel参数类型: {type(vessel)}")
+        return ""
+
+def get_vessel_display_info(vessel: Union[str, dict]) -> str:
+    """
+    获取容器的显示信息（用于日志）
+    
+    Args:
+        vessel: vessel字典或vessel_id字符串
+        
+    Returns:
+        str: 显示信息
+    """
+    if isinstance(vessel, dict):
+        vessel_id = vessel.get("id", "unknown")
+        vessel_name = vessel.get("name", "")
+        if vessel_name:
+            return f"{vessel_id} ({vessel_name})"
+        else:
+            return vessel_id
+    else:
+        return str(vessel)
 
 def generate_stir_protocol(
     G: nx.DiGraph,
-    stir_time: float,
-    stir_speed: float,
-    settling_time: float
+    vessel: Union[str, dict],  # 支持vessel字典或字符串
+    time: Union[str, float, int] = "300",
+    stir_time: Union[str, float, int] = "0",
+    time_spec: str = "",
+    event: str = "",
+    stir_speed: float = 300.0,
+    settling_time: Union[str, float] = "60",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成搅拌操作的协议序列
+    """生成搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    Args:
-        G: 有向图，节点为设备和容器
-        stir_time: 搅拌时间 (秒)
-        stir_speed: 搅拌速度 (rpm)
-        settling_time: 沉降时间 (秒)
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    Returns:
-        List[Dict[str, Any]]: 搅拌操作的动作序列
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "parent": "",
+            "pose": {
+                "orientation": {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0},
+                "position": {"x": 0.0, "y": 0.0, "z": 0.0}
+            },
+            "sample_id": "",
+            "type": ""
+        }
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
     
-    Raises:
-        ValueError: 当找不到搅拌设备时抛出异常
+    debug_print("🌪️" * 20)
+    debug_print("🚀 开始生成搅拌协议（支持vessel字典）✨")
+    debug_print(f"📝 输入参数:")
+    debug_print(f"  🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"  ⏰ time: {time}")
+    debug_print(f"  🕐 stir_time: {stir_time}")
+    debug_print(f"  🎯 time_spec: {time_spec}")
+    debug_print(f"  🌪️ stir_speed: {stir_speed} RPM")
+    debug_print(f"  ⏱️ settling_time: {settling_time}")
+    debug_print("🌪️" * 20)
+    
+    # 📋 参数验证
+    debug_print("📍 步骤1: 参数验证... 🔧")
+    if not vessel_id:  # 🔧 使用 vessel_id
+        debug_print("❌ vessel 参数不能为空! 😱")
+        raise ValueError("vessel 参数不能为空")
+    
+    if vessel_id not in G.nodes():  # 🔧 使用 vessel_id
+        debug_print(f"❌ 容器 '{vessel_id}' 不存在于系统中! 😞")
+        raise ValueError(f"容器 '{vessel_id}' 不存在于系统中")
+    
+    debug_print("✅ 基础参数验证通过 🎯")
+    
+    # 🔄 参数解析
+    debug_print("📍 步骤2: 参数解析... ⚡")
+    
+    # 确定实际时间（优先级：time_spec > stir_time > time）
+    if time_spec:
+        parsed_time = parse_time_input(time_spec)
+        debug_print(f"🎯 使用time_spec: '{time_spec}' → {parsed_time}s")
+    elif stir_time not in ["0", 0, 0.0]:
+        parsed_time = parse_time_input(stir_time)
+        debug_print(f"🎯 使用stir_time: {stir_time} → {parsed_time}s")
+    else:
+        parsed_time = parse_time_input(time)
+        debug_print(f"🎯 使用time: {time} → {parsed_time}s")
+    
+    # 解析沉降时间
+    parsed_settling_time = parse_time_input(settling_time)
+    
+    # 🕐 模拟运行时间优化
+    debug_print("  ⏱️ 检查模拟运行时间限制...")
+    original_stir_time = parsed_time
+    original_settling_time = parsed_settling_time
+    
+    # 搅拌时间限制为60秒
+    stir_time_limit = 60.0
+    if parsed_time > stir_time_limit:
+        parsed_time = stir_time_limit
+        debug_print(f"  🎮 搅拌时间优化: {original_stir_time}s → {parsed_time}s ⚡")
+    
+    # 沉降时间限制为30秒
+    settling_time_limit = 30.0
+    if parsed_settling_time > settling_time_limit:
+        parsed_settling_time = settling_time_limit
+        debug_print(f"  🎮 沉降时间优化: {original_settling_time}s → {parsed_settling_time}s ⚡")
+    
+    # 参数修正
+    parsed_time, stir_speed, parsed_settling_time = validate_and_fix_params(
+        parsed_time, stir_speed, parsed_settling_time
+    )
+    
+    debug_print(f"🎯 最终参数: time={parsed_time}s, speed={stir_speed}RPM, settling={parsed_settling_time}s")
+    
+    # 🔍 查找设备
+    debug_print("📍 步骤3: 查找搅拌设备... 🔍")
+    try:
+        stirrer_id = find_connected_stirrer(G, vessel_id)  # 🔧 使用 vessel_id
+        debug_print(f"🎉 使用搅拌设备: {stirrer_id} ✨")
+    except Exception as e:
+        debug_print(f"❌ 设备查找失败: {str(e)} 😭")
+        raise ValueError(f"无法找到搅拌设备: {str(e)}")
+    
+    # 🚀 生成动作
+    debug_print("📍 步骤4: 生成搅拌动作... 🌪️")
     
-    Examples:
-        stir_protocol = generate_stir_protocol(G, 300.0, 500.0, 60.0)
-    """
     action_sequence = []
-    
-    # 查找搅拌设备
-    stirrer_nodes = [node for node in G.nodes() 
-                    if G.nodes[node].get('class') == 'virtual_stirrer']
-    
-    if not stirrer_nodes:
-        raise ValueError("没有找到可用的搅拌设备")
-    
-    # 使用第一个可用的搅拌器
-    stirrer_id = stirrer_nodes[0]
-    
-    # 执行搅拌操作
-    action_sequence.append({
+    stir_action = {
         "device_id": stirrer_id,
         "action_name": "stir",
         "action_kwargs": {
-            "stir_time": stir_time,
-            "stir_speed": stir_speed,
-            "settling_time": settling_time
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
+            "time": str(time),
+            "event": event,
+            "time_spec": time_spec,
+            "stir_time": float(parsed_time),
+            "stir_speed": float(stir_speed),
+            "settling_time": float(parsed_settling_time)
         }
-    })
+    }
+    action_sequence.append(stir_action)
+    debug_print("✅ 搅拌动作已添加 🌪️✨")
+    
+    # 显示时间优化信息
+    if original_stir_time != parsed_time or original_settling_time != parsed_settling_time:
+        debug_print(f"  🎭 模拟优化说明:")
+        debug_print(f"    搅拌时间: {original_stir_time/60:.1f}分钟 → {parsed_time/60:.1f}分钟")
+        debug_print(f"    沉降时间: {original_settling_time/60:.1f}分钟 → {parsed_settling_time/60:.1f}分钟")
+    
+    # 🎊 总结
+    debug_print("🎊" * 20)
+    debug_print(f"🎉 搅拌协议生成完成! ✨")
+    debug_print(f"📊 总动作数: {len(action_sequence)} 个")
+    debug_print(f"🥽 搅拌容器: {vessel_display}")
+    debug_print(f"🌪️ 搅拌参数: {stir_speed} RPM, {parsed_time}s, 沉降 {parsed_settling_time}s")
+    debug_print(f"⏱️ 预计总时间: {(parsed_time + parsed_settling_time)/60:.1f} 分钟 ⌛")
+    debug_print("🎊" * 20)
     
     return action_sequence
 
-
 def generate_start_stir_protocol(
     G: nx.DiGraph,
-    vessel: str,
-    stir_speed: float,
-    purpose: str
+    vessel: Union[str, dict],
+    stir_speed: float = 300.0,
+    purpose: str = "",
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成开始搅拌操作的协议序列
+    """生成开始搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    Args:
-        G: 有向图，节点为设备和容器
-        vessel: 搅拌容器
-        stir_speed: 搅拌速度 (rpm)
-        purpose: 搅拌目的
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    Returns:
-        List[Dict[str, Any]]: 开始搅拌操作的动作序列
-    """
-    action_sequence = []
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "parent": "",
+            "pose": {
+                "orientation": {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0},
+                "position": {"x": 0.0, "y": 0.0, "z": 0.0}
+            },
+            "sample_id": "",
+            "type": ""
+        }
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
     
-    # 查找搅拌设备
-    stirrer_nodes = [node for node in G.nodes() 
-                    if G.nodes[node].get('class') == 'virtual_stirrer']
+    debug_print("🔄 开始生成启动搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
+    debug_print(f"🌪️ speed: {stir_speed} RPM")
+    debug_print(f"🎯 purpose: {purpose}")
     
-    if not stirrer_nodes:
-        raise ValueError("没有找到可用的搅拌设备")
+    # 基础验证
+    if not vessel_id or vessel_id not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    stirrer_id = stirrer_nodes[0]
+    # 参数修正
+    if stir_speed < 10.0 or stir_speed > 1500.0:
+        debug_print(f"⚠️ 搅拌速度修正: {stir_speed} → 300 RPM 🌪️")
+        stir_speed = 300.0
     
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
+    # 查找设备
+    stirrer_id = find_connected_stirrer(G, vessel_id)
     
-    action_sequence.append({
+    # 🔧 关键修复：传递vessel_id字符串
+    action_sequence = [{
         "device_id": stirrer_id,
         "action_name": "start_stir",
         "action_kwargs": {
-            "vessel": vessel,
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
             "stir_speed": stir_speed,
-            "purpose": purpose
+            "purpose": purpose or f"启动搅拌 {stir_speed} RPM"
         }
-    })
+    }]
     
+    debug_print(f"✅ 启动搅拌协议生成完成 🎯")
     return action_sequence
 
-
 def generate_stop_stir_protocol(
     G: nx.DiGraph,
-    vessel: str
+    vessel: Union[str, dict],
+    **kwargs
 ) -> List[Dict[str, Any]]:
-    """
-    生成停止搅拌操作的协议序列
+    """生成停止搅拌操作的协议序列 - 修复vessel参数传递"""
     
-    Args:
-        G: 有向图，节点为设备和容器
-        vessel: 搅拌容器
+    # 🔧 核心修改：正确处理vessel参数
+    vessel_id = extract_vessel_id(vessel)
+    vessel_display = get_vessel_display_info(vessel)
     
-    Returns:
-        List[Dict[str, Any]]: 停止搅拌操作的动作序列
-    """
-    action_sequence = []
+    # 🔧 关键修复：确保vessel_resource是完整的Resource对象
+    if isinstance(vessel, dict):
+        vessel_resource = vessel  # 已经是完整的Resource字典
+        debug_print(f"✅ 使用传入的vessel Resource对象")
+    else:
+        # 如果只是字符串，构建一个基本的Resource对象
+        vessel_resource = {
+            "id": vessel,
+            "name": "",
+            "category": "",
+            "children": [],
+            "config": "",
+            "data": "",
+            "parent": "",
+            "pose": {
+                "orientation": {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0},
+                "position": {"x": 0.0, "y": 0.0, "z": 0.0}
+            },
+            "sample_id": "",
+            "type": ""
+        }
+        debug_print(f"🔧 构建了基本的vessel Resource对象: {vessel}")
     
-    # 查找搅拌设备
-    stirrer_nodes = [node for node in G.nodes() 
-                    if G.nodes[node].get('class') == 'virtual_stirrer']
+    debug_print("🛑 开始生成停止搅拌协议（修复vessel参数）✨")
+    debug_print(f"🥽 vessel: {vessel_display} (ID: {vessel_id})")
     
-    if not stirrer_nodes:
-        raise ValueError("没有找到可用的搅拌设备")
+    # 基础验证
+    if not vessel_id or vessel_id not in G.nodes():
+        debug_print("❌ 容器验证失败!")
+        raise ValueError("vessel 参数无效")
     
-    stirrer_id = stirrer_nodes[0]
+    # 查找设备
+    stirrer_id = find_connected_stirrer(G, vessel_id)
     
-    # 验证容器是否存在
-    if vessel not in G.nodes():
-        raise ValueError(f"容器 {vessel} 不存在于图中")
-    
-    action_sequence.append({
+    # 🔧 关键修复：传递vessel_id字符串
+    action_sequence = [{
         "device_id": stirrer_id,
         "action_name": "stop_stir",
         "action_kwargs": {
-            "vessel": vessel
+            # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
+            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
         }
-    })
+    }]
     
+    debug_print(f"✅ 停止搅拌协议生成完成 🎯")
     return action_sequence
+
+# 🔧 新增：便捷函数
+def stir_briefly(G: nx.DiGraph, vessel: Union[str, dict], 
+                speed: float = 300.0) -> List[Dict[str, Any]]:
+    """短时间搅拌（30秒）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"⚡ 短时间搅拌: {vessel_display} @ {speed}RPM (30s)")
+    return generate_stir_protocol(G, vessel, time="30", stir_speed=speed)
+
+def stir_slowly(G: nx.DiGraph, vessel: Union[str, dict], 
+               time: Union[str, float] = "10 min") -> List[Dict[str, Any]]:
+    """慢速搅拌"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🐌 慢速搅拌: {vessel_display} @ 150RPM")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=150.0)
+
+def stir_vigorously(G: nx.DiGraph, vessel: Union[str, dict], 
+                   time: Union[str, float] = "5 min") -> List[Dict[str, Any]]:
+    """剧烈搅拌"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"💨 剧烈搅拌: {vessel_display} @ 800RPM")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=800.0)
+
+def stir_for_reaction(G: nx.DiGraph, vessel: Union[str, dict], 
+                     time: Union[str, float] = "1 h") -> List[Dict[str, Any]]:
+    """反应搅拌（标准速度，长时间）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🧪 反应搅拌: {vessel_display} @ 400RPM")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=400.0)
+
+def stir_for_dissolution(G: nx.DiGraph, vessel: Union[str, dict], 
+                        time: Union[str, float] = "15 min") -> List[Dict[str, Any]]:
+    """溶解搅拌（中等速度）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"💧 溶解搅拌: {vessel_display} @ 500RPM")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=500.0)
+
+def stir_gently(G: nx.DiGraph, vessel: Union[str, dict], 
+               time: Union[str, float] = "30 min") -> List[Dict[str, Any]]:
+    """温和搅拌"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🍃 温和搅拌: {vessel_display} @ 200RPM")
+    return generate_stir_protocol(G, vessel, time=time, stir_speed=200.0)
+
+def stir_overnight(G: nx.DiGraph, vessel: Union[str, dict]) -> List[Dict[str, Any]]:
+    """过夜搅拌（模拟时缩短为2小时）"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🌙 过夜搅拌（模拟2小时）: {vessel_display} @ 300RPM")
+    return generate_stir_protocol(G, vessel, time="2 h", stir_speed=300.0)
+
+def start_continuous_stirring(G: nx.DiGraph, vessel: Union[str, dict], 
+                             speed: float = 300.0, purpose: str = "continuous stirring") -> List[Dict[str, Any]]:
+    """开始连续搅拌"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🔄 开始连续搅拌: {vessel_display} @ {speed}RPM")
+    return generate_start_stir_protocol(G, vessel, stir_speed=speed, purpose=purpose)
+
+def stop_all_stirring(G: nx.DiGraph, vessel: Union[str, dict]) -> List[Dict[str, Any]]:
+    """停止所有搅拌"""
+    vessel_display = get_vessel_display_info(vessel)
+    debug_print(f"🛑 停止搅拌: {vessel_display}")
+    return generate_stop_stir_protocol(G, vessel)
+
+# 测试函数
+def test_stir_protocol():
+    """测试搅拌协议"""
+    debug_print("🧪 === STIR PROTOCOL 测试 === ✨")
+    
+    # 测试vessel参数处理
+    debug_print("🔧 测试vessel参数处理...")
+    
+    # 测试字典格式
+    vessel_dict = {"id": "flask_1", "name": "反应瓶1"}
+    vessel_id = extract_vessel_id(vessel_dict)
+    vessel_display = get_vessel_display_info(vessel_dict)
+    debug_print(f"  字典格式: {vessel_dict} → ID: {vessel_id}, 显示: {vessel_display}")
+    
+    # 测试字符串格式
+    vessel_str = "flask_2"
+    vessel_id = extract_vessel_id(vessel_str)
+    vessel_display = get_vessel_display_info(vessel_str)
+    debug_print(f"  字符串格式: {vessel_str} → ID: {vessel_id}, 显示: {vessel_display}")
+    
+    debug_print("✅ 测试完成 🎉")
+
+if __name__ == "__main__":
+    test_stir_protocol()