Merge branch 'dev' into prcix9320

(cherry picked from commit 176de521b4)

.conda/base/recipe.yaml

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

.conda/environment/recipe.yaml

@@ -0,0 +1,39 @@
+# unilabos-env: conda environment dependencies (ROS2 + conda packages)
+
+package:
+  name: unilabos-env
+  version: 0.10.17
+
+build:
+  noarch: generic
+
+requirements:
+  run:
+  # Python
+  - zstd
+  - zstandard
+  - conda-forge::python ==3.11.14
+  - conda-forge::opencv
+  # ROS2 dependencies (from ci-check.yml)
+  - robostack-staging::ros-humble-ros-core
+  - robostack-staging::ros-humble-action-msgs
+  - robostack-staging::ros-humble-std-msgs
+  - robostack-staging::ros-humble-geometry-msgs
+  - robostack-staging::ros-humble-control-msgs
+  - robostack-staging::ros-humble-nav2-msgs
+  - robostack-staging::ros-humble-cv-bridge
+  - robostack-staging::ros-humble-vision-opencv
+  - robostack-staging::ros-humble-tf-transformations
+  - robostack-staging::ros-humble-moveit-msgs
+  - robostack-staging::ros-humble-tf2-ros
+  - robostack-staging::ros-humble-tf2-ros-py
+  - conda-forge::transforms3d
+  - conda-forge::uv
+
+  # UniLabOS custom messages
+  - uni-lab::ros-humble-unilabos-msgs
+
+about:
+  repository: https://github.com/deepmodeling/Uni-Lab-OS
+  license: GPL-3.0-only
+  description: "UniLabOS Environment - ROS2 and conda dependencies"

.conda/full/recipe.yaml

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

.conda/recipe.yaml

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

.github/workflows/ci-check.yml

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

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

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

.github/workflows/deploy-docs.yml

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

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

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

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

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

MANIFEST.in

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

README.md

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

README_zh.md

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

docs/user_guide/best_practice.md

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

docs/user_guide/installation.md

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

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

scripts/create_readme.py

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

scripts/dev_install.py

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

setup.py

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

tests/devices/liquid_handling/README.md

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

tests/devices/liquid_handling/unit_test.py

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

tests/workflow/test.json

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

unilabos/__init__.py

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

unilabos/app/main.py

@@ -7,7 +7,6 @@ import sys
 import threading
 import time
 from typing import Dict, Any, List
-
 import networkx as nx
 import yaml
 
@@ -17,9 +16,9 @@ unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
     sys.path.append(unilabos_dir)
 
+from unilabos.app.utils import cleanup_for_restart
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
-from unilabos.app.utils import cleanup_for_restart
 
 # Global restart flags (used by ws_client and web/server)
 _restart_requested: bool = False
@@ -161,6 +160,12 @@ def parse_args():
         default=False,
         help="Complete registry information",
     )
+    parser.add_argument(
+        "--check_mode",
+        action="store_true",
+        default=False,
+        help="Run in check mode for CI: validates registry imports and ensures no file changes",
+    )
     parser.add_argument(
         "--no_update_feedback",
         action="store_true",
@@ -211,7 +216,10 @@ def main():
     args_dict = vars(args)
 
     # 环境检查 - 检查并自动安装必需的包 (可选)
-    if not args_dict.get("skip_env_check", False):
+    skip_env_check = args_dict.get("skip_env_check", False)
+    check_mode = args_dict.get("check_mode", False)
+
+    if not skip_env_check:
         from unilabos.utils.environment_check import check_environment
 
         if not check_environment(auto_install=True):
@@ -222,7 +230,21 @@ def main():
 
     # 加载配置文件，优先加载config，然后从env读取
     config_path = args_dict.get("config")
-    if os.getcwd().endswith("unilabos_data"):
+
+    if check_mode:
+        args_dict["working_dir"] = os.path.abspath(os.getcwd())
+    # 当 skip_env_check 时，默认使用当前目录作为 working_dir
+    if skip_env_check and not args_dict.get("working_dir") and not config_path:
+        working_dir = os.path.abspath(os.getcwd())
+        print_status(f"跳过环境检查模式：使用当前目录作为工作目录 {working_dir}", "info")
+        # 检查当前目录是否有 local_config.py
+        local_config_in_cwd = os.path.join(working_dir, "local_config.py")
+        if os.path.exists(local_config_in_cwd):
+            config_path = local_config_in_cwd
+            print_status(f"发现本地配置文件: {config_path}", "info")
+        else:
+            print_status(f"未指定config路径，可通过 --config 传入 local_config.py 文件路径", "info")
+    elif 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"))
@@ -241,7 +263,7 @@ def main():
         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 (
+    elif not skip_env_check and 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")
@@ -255,9 +277,11 @@ def main():
             print_status(f"已创建 local_config.py 路径： {config_path}", "info")
         else:
             os._exit(1)
-    # 加载配置文件
+
+    # 加载配置文件 (check_mode 跳过)
     print_status(f"当前工作目录为 {working_dir}", "info")
-    load_config_from_file(config_path)
+    if not check_mode:
+        load_config_from_file(config_path)
 
     # 根据配置重新设置日志级别
     from unilabos.utils.log import configure_logger, logger
@@ -313,6 +337,7 @@ def main():
     machine_name = "".join([c if c.isalnum() or c == "_" else "_" for c in machine_name])
     BasicConfig.machine_name = machine_name
     BasicConfig.vis_2d_enable = args_dict["2d_vis"]
+    BasicConfig.check_mode = check_mode
 
     from unilabos.resources.graphio import (
         read_node_link_json,
@@ -331,10 +356,14 @@ def main():
     # 显示启动横幅
     print_unilab_banner(args_dict)
 
-    # 注册表
-    lab_registry = build_registry(
-        args_dict["registry_path"], args_dict.get("complete_registry", False), BasicConfig.upload_registry
-    )
+    # 注册表 - check_mode 时强制启用 complete_registry
+    complete_registry = args_dict.get("complete_registry", False) or check_mode
+    lab_registry = build_registry(args_dict["registry_path"], complete_registry, BasicConfig.upload_registry)
+
+    # Check mode: complete_registry 完成后直接退出，git diff 检测由 CI workflow 执行
+    if check_mode:
+        print_status("Check mode: complete_registry 完成，退出", "info")
+        os._exit(0)
 
     if BasicConfig.upload_registry:
         # 设备注册到服务端 - 需要 ak 和 sk

unilabos/app/utils.py

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

unilabos/app/web/client.py

@@ -359,9 +359,7 @@ class HTTPClient:
         Returns:
             Dict: API响应数据，包含 code 和 data (uuid, name)
         """
-        # target_lab_uuid 暂时使用默认值，后续由后端根据 ak/sk 获取
         payload = {
-            "target_lab_uuid": "28c38bb0-63f6-4352-b0d8-b5b8eb1766d5",
             "name": name,
             "data": {
                 "workflow_uuid": workflow_uuid,

unilabos/app/ws_client.py

@@ -848,7 +848,7 @@ class MessageProcessor:
                     device_action_groups[key_add].append(item["uuid"])
 
                     logger.info(
-                        f"[MessageProcessor] Resource migrated: {item['uuid'][:8]} from {device_old_id} to {device_id}"
+                        f"[资源同步] 跨站Transfer: {item['uuid'][:8]} from {device_old_id} to {device_id}"
                     )
                 else:
                     # 正常update
@@ -863,12 +863,11 @@ class MessageProcessor:
                     device_action_groups[key] = []
                 device_action_groups[key].append(item["uuid"])
 
-        logger.info(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")
-        logger.trace(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, {resource_uuid_list}")
+        logger.trace(f"[资源同步] 动作 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")
 
         # 为每个(device_id, action)创建独立的更新线程
         for (device_id, actual_action), items in device_action_groups.items():
-            logger.info(f"设备 {device_id} 物料更新 {actual_action} 数量: {len(items)}")
+            logger.trace(f"[资源同步] {device_id} 物料动作 {actual_action} 数量: {len(items)}")
 
             def _notify_resource_tree(dev_id, act, item_list):
                 try:

unilabos/device_comms/opcua_client/node/uniopcua.py

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

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -176,40 +176,7 @@ class BioyondV1RPC(BaseRequest):
             return {}
 
         print(f"add material data: {response['data']}")
-
-        # 自动更新缓存
-        data = response.get("data", {})
-        if data:
-            if isinstance(data, str):
-                # 如果返回的是字符串，通常是ID
-                mat_id = data
-                name = params.get("name")
-            else:
-                # 如果返回的是字典，尝试获取name和id
-                name = data.get("name") or params.get("name")
-                mat_id = data.get("id")
-
-            if name and mat_id:
-                self.material_cache[name] = mat_id
-                print(f"已自动更新缓存: {name} -> {mat_id}")
-
-            # 处理返回数据中的 details (如果有)
-            # 有些 API 返回结构可能直接包含 details，或者在 data 字段中
-            details = data.get("details", []) if isinstance(data, dict) else []
-            if not details and isinstance(data, dict):
-                 details = data.get("detail", [])
-
-            if details:
-                for detail in details:
-                    d_name = detail.get("name")
-                    # 尝试从不同字段获取 ID
-                    d_id = detail.get("id") or detail.get("detailMaterialId")
-
-                    if d_name and d_id:
-                        self.material_cache[d_name] = d_id
-                        print(f"已自动更新 detail 缓存: {d_name} -> {d_id}")
-
-        return data
+        return response.get("data", {})
 
     def query_matial_type_id(self, data) -> list:
         """查找物料typeid"""
@@ -236,7 +203,7 @@ class BioyondV1RPC(BaseRequest):
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
-                "data": 0,
+                "data": {},
             })
         if not response or response['code'] != 1:
             return []
@@ -306,14 +273,6 @@ class BioyondV1RPC(BaseRequest):
 
         if not response or response['code'] != 1:
             return {}
-
-        # 自动更新缓存 - 移除被删除的物料
-        for name, mid in list(self.material_cache.items()):
-            if mid == material_id:
-                del self.material_cache[name]
-                print(f"已从缓存移除物料: {name}")
-                break
-
         return response.get("data", {})
 
     def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
@@ -1144,10 +1103,6 @@ class BioyondV1RPC(BaseRequest):
                     for detail_material in detail_materials:
                         detail_name = detail_material.get("name")
                         detail_id = detail_material.get("detailMaterialId")
-                        if not detail_id:
-                            # 尝试其他可能的字段
-                            detail_id = detail_material.get("id")
-
                         if detail_name and detail_id:
                             self.material_cache[detail_name] = detail_id
                             print(f"加载detail材料: {detail_name} -> ID: {detail_id}")
@@ -1168,14 +1123,6 @@ class BioyondV1RPC(BaseRequest):
             print(f"从缓存找到材料: {material_name_or_id} -> ID: {material_id}")
             return material_id
 
-        # 如果缓存中没有，尝试刷新缓存
-        print(f"缓存中未找到材料 '{material_name_or_id}'，尝试刷新缓存...")
-        self.refresh_material_cache()
-        if material_name_or_id in self.material_cache:
-            material_id = self.material_cache[material_name_or_id]
-            print(f"刷新缓存后找到材料: {material_name_or_id} -> ID: {material_id}")
-            return material_id
-
         print(f"警告: 未在缓存中找到材料名称 '{material_name_or_id}'，将使用原值")
         return material_name_or_id
 

unilabos/devices/workstation/bioyond_studio/dispensing_station.py

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

unilabos/devices/workstation/bioyond_studio/station.py

@@ -6,7 +6,6 @@ Bioyond Workstation Implementation
 """
 import time
 import traceback
-import threading
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Union
 import json
@@ -30,90 +29,6 @@ from unilabos.devices.workstation.bioyond_studio.config import (
 from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
 
 
-class ConnectionMonitor:
-    """Bioyond连接监控器"""
-    def __init__(self, workstation, check_interval=30):
-        self.workstation = workstation
-        self.check_interval = check_interval
-        self._running = False
-        self._thread = None
-        self._last_status = "unknown"
-
-    def start(self):
-        if self._running:
-            return
-        self._running = True
-        self._thread = threading.Thread(target=self._monitor_loop, daemon=True, name="BioyondConnectionMonitor")
-        self._thread.start()
-        logger.info("Bioyond连接监控器已启动")
-
-    def stop(self):
-        self._running = False
-        if self._thread:
-            self._thread.join(timeout=2)
-            logger.info("Bioyond连接监控器已停止")
-
-    def _monitor_loop(self):
-        while self._running:
-            try:
-                # 使用 lightweight API 检查连接
-                # query_matial_type_list 是比较快的查询
-                start_time = time.time()
-                result = self.workstation.hardware_interface.material_type_list()
-
-                status = "online" if result else "offline"
-                msg = "Connection established" if status == "online" else "Failed to get material type list"
-
-                if status != self._last_status:
-                    logger.info(f"Bioyond连接状态变更: {self._last_status} -> {status}")
-                    self._publish_event(status, msg)
-                    self._last_status = status
-
-                # 发布心跳 (可选，或者只在状态变更时发布)
-                # self._publish_event(status, msg)
-
-            except Exception as e:
-                logger.error(f"Bioyond连接检查异常: {e}")
-                if self._last_status != "error":
-                    self._publish_event("error", str(e))
-                    self._last_status = "error"
-
-            time.sleep(self.check_interval)
-
-    def _publish_event(self, status, message):
-        try:
-            if hasattr(self.workstation, "_ros_node") and self.workstation._ros_node:
-                event_data = {
-                    "status": status,
-                    "message": message,
-                    "timestamp": datetime.now().isoformat()
-                }
-
-                # 动态发布消息，需要在 ROS2DeviceNode 中有对应支持
-                # 这里假设通用事件发布机制，使用 String 类型的 topic
-                # 话题: /<namespace>/events/device_status
-                ns = self.workstation._ros_node.namespace
-                topic = f"{ns}/events/device_status"
-
-                # 使用 ROS2DeviceNode 的发布功能
-                # 如果没有预定义的 publisher，需要动态创建
-                # 注意：workstation base node 可能没有自动创建 arbitrary publishers 的机制
-                # 这里我们先尝试用 String json 发布
-
-                # 在 ROS2DeviceNode 中通常需要先 create_publisher
-                # 为了简单起见，我们检查是否已有 publisher，没有则创建
-                if not hasattr(self.workstation, "_device_status_pub"):
-                    self.workstation._device_status_pub = self.workstation._ros_node.create_publisher(
-                        String, topic, 10
-                    )
-
-                self.workstation._device_status_pub.publish(
-                    convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
-                )
-        except Exception as e:
-            logger.error(f"发布设备状态事件失败: {e}")
-
-
 class BioyondResourceSynchronizer(ResourceSynchronizer):
     """Bioyond资源同步器
 
@@ -324,18 +239,13 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
             logger.info(f"[同步→Bioyond] 🔄 转换物料为 Bioyond 格式...")
 
             # 导入物料默认参数配置
-            from .config import MATERIAL_DEFAULT_PARAMETERS, MATERIAL_TYPE_PARAMETERS
-
-            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
-            merged_params = MATERIAL_DEFAULT_PARAMETERS.copy()
-            for type_id, params in MATERIAL_TYPE_PARAMETERS.items():
-                merged_params[f"type:{type_id}"] = params
+            from .config import MATERIAL_DEFAULT_PARAMETERS
 
             bioyond_material = resource_plr_to_bioyond(
                 [resource],
                 type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                 warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
             )[0]
 
             logger.info(f"[同步→Bioyond] 🔧 准备覆盖locations字段，目标仓库: {parent_name}, 库位: {update_site}, UUID: {target_location_uuid[:8]}...")
@@ -558,18 +468,13 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 return material_bioyond_id
 
             # 转换为 Bioyond 格式
-            from .config import MATERIAL_DEFAULT_PARAMETERS, MATERIAL_TYPE_PARAMETERS
-
-            # 合并参数配置：物料名称参数 + typeId参数（转换为 type:<uuid> 格式）
-            merged_params = MATERIAL_DEFAULT_PARAMETERS.copy()
-            for type_id, params in MATERIAL_TYPE_PARAMETERS.items():
-                merged_params[f"type:{type_id}"] = params
+            from .config import MATERIAL_DEFAULT_PARAMETERS
 
             bioyond_material = resource_plr_to_bioyond(
                 [resource],
                 type_mapping=self.workstation.bioyond_config["material_type_mappings"],
                 warehouse_mapping=self.workstation.bioyond_config["warehouse_mapping"],
-                material_params=merged_params
+                material_params=MATERIAL_DEFAULT_PARAMETERS
             )[0]
 
             # ⚠️ 关键：创建物料时不设置 locations，让 Bioyond 系统暂不分配库位
@@ -679,44 +584,6 @@ class BioyondWorkstation(WorkstationBase):
     集成Bioyond物料管理的工作站实现
     """
 
-    def _publish_task_status(
-        self,
-        task_id: str,
-        task_type: str,
-        status: str,
-        result: dict = None,
-        progress: float = 0.0,
-        task_code: str = None
-    ):
-        """发布任务状态事件"""
-        try:
-            if not getattr(self, "_ros_node", None):
-                return
-
-            event_data = {
-                "task_id": task_id,
-                "task_code": task_code,
-                "task_type": task_type,
-                "status": status,
-                "progress": progress,
-                "timestamp": datetime.now().isoformat()
-            }
-            if result:
-                event_data["result"] = result
-
-            topic = f"{self._ros_node.namespace}/events/task_status"
-
-            if not hasattr(self, "_task_status_pub"):
-                self._task_status_pub = self._ros_node.create_publisher(
-                    String, topic, 10
-                )
-
-            self._task_status_pub.publish(
-                convert_to_ros_msg(String, json.dumps(event_data, ensure_ascii=False))
-            )
-        except Exception as e:
-            logger.error(f"发布任务状态事件失败: {e}")
-
     def __init__(
         self,
         bioyond_config: Optional[Dict[str, Any]] = None,
@@ -765,16 +632,13 @@ class BioyondWorkstation(WorkstationBase):
             "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG["http_service_host"]),
             "port": bioyond_config.get("http_service_port", HTTP_SERVICE_CONFIG["http_service_port"])
         }
-        self.http_service = None  # 将在 post_init 启动
-        self.connection_monitor = None # 将在 post_init 启动
+        self.http_service = None  # 将在 post_init 中启动
 
         logger.info(f"Bioyond工作站初始化完成")
 
     def __del__(self):
         """析构函数：清理资源，停止 HTTP 服务"""
         try:
-            if hasattr(self, 'connection_monitor') and self.connection_monitor:
-                self.connection_monitor.stop()
             if hasattr(self, 'http_service') and self.http_service is not None:
                 logger.info("正在停止 HTTP 报送服务...")
                 self.http_service.stop()
@@ -784,13 +648,6 @@ class BioyondWorkstation(WorkstationBase):
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
 
-        # 启动连接监控
-        try:
-            self.connection_monitor = ConnectionMonitor(self)
-            self.connection_monitor.start()
-        except Exception as e:
-            logger.error(f"启动连接监控失败: {e}")
-
         # 启动 HTTP 报送接收服务（现在 device_id 已可用）
         if hasattr(self, '_http_service_config'):
             try:
@@ -1157,15 +1014,7 @@ class BioyondWorkstation(WorkstationBase):
 
         workflow_id = self._get_workflow(actual_workflow_name)
         if workflow_id:
-            # 兼容 BioyondReactionStation 中 workflow_sequence 被重写为 property 的情况
-            if isinstance(self.workflow_sequence, list):
-                self.workflow_sequence.append(workflow_id)
-            elif hasattr(self, "_cached_workflow_sequence") and isinstance(self._cached_workflow_sequence, list):
-                self._cached_workflow_sequence.append(workflow_id)
-            else:
-                print(f"❌ 无法添加工作流: workflow_sequence 类型错误 {type(self.workflow_sequence)}")
-                return False
-
+            self.workflow_sequence.append(workflow_id)
             print(f"添加工作流到执行顺序: {actual_workflow_name} -> {workflow_id}")
             return True
         return False
@@ -1366,22 +1215,6 @@ class BioyondWorkstation(WorkstationBase):
             # TODO: 根据实际业务需求处理步骤完成逻辑
             # 例如：更新数据库、触发后续流程等
 
-            # 发布任务状态事件 (running/progress update)
-            self._publish_task_status(
-                task_id=data.get('orderCode'), # 使用 OrderCode 作为关联 ID
-                task_code=data.get('orderCode'),
-                task_type="bioyond_step",
-                status="running",
-                progress=0.5, # 步骤完成视为任务进行中
-                result={"step_name": data.get('stepName'), "step_id": data.get('stepId')}
-            )
-
-            # 更新物料信息
-            # 步骤完成后，物料状态可能发生变化（如位置、用量等），触发同步
-            logger.info(f"[步骤完成报送] 触发物料同步...")
-            self.resource_synchronizer.sync_from_external()
-
-
             return {
                 "processed": True,
                 "step_id": data.get('stepId'),
@@ -1416,17 +1249,6 @@ class BioyondWorkstation(WorkstationBase):
 
             # TODO: 根据实际业务需求处理通量完成逻辑
 
-            # 发布任务状态事件
-            self._publish_task_status(
-                task_id=data.get('orderCode'),
-                task_code=data.get('orderCode'),
-                task_type="bioyond_sample",
-                status="running",
-                progress=0.7,
-                result={"sample_id": data.get('sampleId'), "status": status_desc}
-            )
-
-
             return {
                 "processed": True,
                 "sample_id": data.get('sampleId'),
@@ -1466,32 +1288,6 @@ class BioyondWorkstation(WorkstationBase):
             # TODO: 根据实际业务需求处理任务完成逻辑
             # 例如：更新物料库存、生成报表等
 
-            # 映射状态到事件状态
-            event_status = "completed"
-            if str(data.get('status')) in ["-11", "-12"]:
-                event_status = "error"
-            elif str(data.get('status')) == "30":
-                event_status = "completed"
-            else:
-                event_status = "running" # 其他状态视为运行中（或根据实际定义）
-
-            # 发布任务状态事件
-            self._publish_task_status(
-                task_id=data.get('orderCode'),
-                task_code=data.get('orderCode'),
-                task_type="bioyond_order",
-                status=event_status,
-                progress=1.0 if event_status in ["completed", "error"] else 0.9,
-                result={"order_name": data.get('orderName'), "status": status_desc, "materials_count": len(used_materials)}
-            )
-
-            # 更新物料信息
-            # 任务完成后，且状态为完成时，触发同步以更新最终物料状态
-            if event_status == "completed":
-                logger.info(f"[任务完成报送] 触发物料同步...")
-                self.resource_synchronizer.sync_from_external()
-
-
             return {
                 "processed": True,
                 "order_code": data.get('orderCode'),

unilabos/devices/workstation/workstation_http_service.py

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

unilabos/registry/devices/bioyond_dispensing_station.yaml

@@ -5,6 +5,229 @@ bioyond_dispensing_station:
   - bioyond_dispensing_station
   class:
     action_value_mappings:
+      auto-brief_step_parameters:
+        feedback: {}
+        goal: {}
+        goal_default:
+          data: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                data:
+                  type: object
+              required:
+              - data
+              type: object
+            result: {}
+          required:
+          - goal
+          title: brief_step_parameters参数
+          type: object
+        type: UniLabJsonCommand
+      auto-compute_experiment_design:
+        feedback: {}
+        goal: {}
+        goal_default:
+          m_tot: '70'
+          ratio: null
+          titration_percent: '0.03'
+          wt_percent: '0.25'
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                m_tot:
+                  default: '70'
+                  type: string
+                ratio:
+                  type: object
+                titration_percent:
+                  default: '0.03'
+                  type: string
+                wt_percent:
+                  default: '0.25'
+                  type: string
+              required:
+              - ratio
+              type: object
+            result:
+              properties:
+                feeding_order:
+                  items: {}
+                  title: Feeding Order
+                  type: array
+                return_info:
+                  title: Return Info
+                  type: string
+                solutions:
+                  items: {}
+                  title: Solutions
+                  type: array
+                solvents:
+                  additionalProperties: true
+                  title: Solvents
+                  type: object
+                titration:
+                  additionalProperties: true
+                  title: Titration
+                  type: object
+              required:
+              - solutions
+              - titration
+              - solvents
+              - feeding_order
+              - return_info
+              title: ComputeExperimentDesignReturn
+              type: object
+          required:
+          - goal
+          title: compute_experiment_design参数
+          type: object
+        type: UniLabJsonCommand
+      auto-process_order_finish_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          report_request: null
+          used_materials: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                report_request:
+                  type: string
+                used_materials:
+                  type: string
+              required:
+              - report_request
+              - used_materials
+              type: object
+            result: {}
+          required:
+          - goal
+          title: process_order_finish_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-project_order_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          order_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                order_id:
+                  type: string
+              required:
+              - order_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: project_order_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-query_resource_by_name:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_name:
+                  type: string
+              required:
+              - material_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: query_resource_by_name参数
+          type: object
+        type: UniLabJsonCommand
+      auto-transfer_materials_to_reaction_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          target_device_id: null
+          transfer_groups: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                target_device_id:
+                  type: string
+                transfer_groups:
+                  type: array
+              required:
+              - target_device_id
+              - transfer_groups
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_materials_to_reaction_station参数
+          type: object
+        type: UniLabJsonCommand
+      auto-workflow_sample_locations:
+        feedback: {}
+        goal: {}
+        goal_default:
+          workflow_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                workflow_id:
+                  type: string
+              required:
+              - workflow_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: workflow_sample_locations参数
+          type: object
+        type: UniLabJsonCommand
       batch_create_90_10_vial_feeding_tasks:
         feedback: {}
         goal:
@@ -171,99 +394,6 @@ bioyond_dispensing_station:
           title: BatchCreateDiamineSolutionTasks
           type: object
         type: UniLabJsonCommand
-      compute_experiment_design:
-        feedback: {}
-        goal:
-          m_tot: m_tot
-          ratio: ratio
-          titration_percent: titration_percent
-          wt_percent: wt_percent
-        goal_default:
-          m_tot: '70'
-          ratio: ''
-          titration_percent: '0.03'
-          wt_percent: '0.25'
-        handles:
-          output:
-          - data_key: solutions
-            data_source: executor
-            data_type: array
-            handler_key: solutions
-            io_type: sink
-            label: Solution Data From Python
-          - data_key: titration
-            data_source: executor
-            data_type: object
-            handler_key: titration
-            io_type: sink
-            label: Titration Data From Calculation Node
-          - data_key: solvents
-            data_source: executor
-            data_type: object
-            handler_key: solvents
-            io_type: sink
-            label: Solvents Data From Calculation Node
-          - data_key: feeding_order
-            data_source: executor
-            data_type: array
-            handler_key: feeding_order
-            io_type: sink
-            label: Feeding Order Data From Calculation Node
-        result:
-          feeding_order: feeding_order
-          return_info: return_info
-          solutions: solutions
-          solvents: solvents
-          titration: titration
-        schema:
-          description: 计算实验设计，输出solutions/titration/solvents/feeding_order用于后续节点。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                m_tot:
-                  default: '70'
-                  description: 总质量(g)
-                  type: string
-                ratio:
-                  description: 组分摩尔比的对象，保持输入顺序，如{"MDA":1,"BTDA":1}
-                  type: string
-                titration_percent:
-                  default: '0.03'
-                  description: 滴定比例(10%部分)
-                  type: string
-                wt_percent:
-                  default: '0.25'
-                  description: 目标固含质量分数
-                  type: string
-              required:
-              - ratio
-              type: object
-            result:
-              properties:
-                feeding_order:
-                  type: array
-                return_info:
-                  type: string
-                solutions:
-                  type: array
-                solvents:
-                  type: object
-                titration:
-                  type: object
-              required:
-              - solutions
-              - titration
-              - solvents
-              - feeding_order
-              - return_info
-              title: ComputeExperimentDesign_Result
-              type: object
-          required:
-          - goal
-          title: ComputeExperimentDesign
-          type: object
-        type: UniLabJsonCommand
       create_90_10_vial_feeding_task:
         feedback: {}
         goal:
@@ -490,89 +620,6 @@ bioyond_dispensing_station:
           title: DispenStationSolnPrep
           type: object
         type: DispenStationSolnPrep
-      scheduler_start:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: 启动调度器 - 启动Bioyond配液站的任务调度器，开始执行队列中的任务
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                return_info:
-                  description: 调度器启动结果，成功返回1，失败返回0
-                  type: integer
-              required:
-              - return_info
-              title: scheduler_start结果
-              type: object
-          required:
-          - goal
-          title: scheduler_start参数
-          type: object
-        type: UniLabJsonCommand
-      transfer_materials_to_reaction_station:
-        feedback: {}
-        goal:
-          target_device_id: target_device_id
-          transfer_groups: transfer_groups
-        goal_default:
-          target_device_id: ''
-          transfer_groups: ''
-        handles: {}
-        placeholder_keys:
-          target_device_id: unilabos_devices
-        result: {}
-        schema:
-          description: 将配液站完成的物料（溶液、样品等）转移到指定反应站的堆栈库位。支持配置多组转移任务，每组包含物料名称、目标堆栈和目标库位。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                target_device_id:
-                  description: 目标反应站设备ID（从设备列表中选择，所有转移组都使用同一个目标设备）
-                  type: string
-                transfer_groups:
-                  description: 转移任务组列表，每组包含物料名称、目标堆栈和目标库位，可以添加多组
-                  items:
-                    properties:
-                      materials:
-                        description: 物料名称（手动输入，系统将通过RPC查询验证）
-                        type: string
-                      target_sites:
-                        description: 目标库位（手动输入，如"A01"）
-                        type: string
-                      target_stack:
-                        description: 目标堆栈名称（从列表选择）
-                        enum:
-                        - 堆栈1左
-                        - 堆栈1右
-                        - 站内试剂存放堆栈
-                        type: string
-                    required:
-                    - materials
-                    - target_stack
-                    - target_sites
-                    type: object
-                  type: array
-              required:
-              - target_device_id
-              - transfer_groups
-              type: object
-            result: {}
-          required:
-          - goal
-          title: transfer_materials_to_reaction_station参数
-          type: object
-        type: UniLabJsonCommand
       wait_for_multiple_orders_and_get_reports:
         feedback: {}
         goal:

unilabos/registry/devices/liquid_handler.yaml

@@ -638,7 +638,7 @@ liquid_handler:
         placeholder_keys: {}
         result: {}
         schema:
-          description: 吸头迭代函数。用于自动管理和切换吸头架中的吸头，实现批量实验中的吸头自动分配和追踪。该函数监控吸头使用状态，自动切换到下一个可用吸头位置，确保实验流程的连续性。适用于高通量实验、批量处理、自动化流水线等需要大量吸头管理的应用场景。
+          description: 吸头迭代函数。用于自动管理和切换枪头盒中的吸头，实现批量实验中的吸头自动分配和追踪。该函数监控吸头使用状态，自动切换到下一个可用吸头位置，确保实验流程的连续性。适用于高通量实验、批量处理、自动化流水线等需要大量吸头管理的应用场景。
           properties:
             feedback: {}
             goal:
@@ -712,6 +712,43 @@ liquid_handler:
           title: set_group参数
           type: object
         type: UniLabJsonCommand
+      auto-set_liquid_from_plate:
+        feedback: {}
+        goal: {}
+        goal_default:
+          liquid_names: null
+          plate: null
+          volumes: null
+          well_names: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                liquid_names:
+                  type: string
+                plate:
+                  type: string
+                volumes:
+                  type: string
+                well_names:
+                  type: string
+              required:
+              - plate
+              - well_names
+              - liquid_names
+              - volumes
+              type: object
+            result: {}
+          required:
+          - goal
+          title: set_liquid_from_plate参数
+          type: object
+        type: UniLabJsonCommand
       auto-set_tiprack:
         feedback: {}
         goal: {}
@@ -721,7 +758,7 @@ liquid_handler:
         placeholder_keys: {}
         result: {}
         schema:
-          description: 吸头架设置函数。用于配置和初始化液体处理系统的吸头架信息，包括吸头架位置、类型、容量等参数。该函数建立吸头资源管理系统，为后续的吸头选择和使用提供基础配置。适用于系统初始化、吸头架更换、实验配置等需要吸头资源管理的操作场景。
+          description: 枪头盒设置函数。用于配置和初始化液体处理系统的枪头盒信息，包括枪头盒位置、类型、容量等参数。该函数建立吸头资源管理系统，为后续的吸头选择和使用提供基础配置。适用于系统初始化、枪头盒更换、实验配置等需要吸头资源管理的操作场景。
           properties:
             feedback: {}
             goal:
@@ -4093,32 +4130,43 @@ liquid_handler:
           - 0
         handles:
           input:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets
             label: targets
-          - data_key: liquid
-            data_source: executor
+          - data_key: tip_racks
+            data_source: handle
+            data_type: resource
+            handler_key: tip_racks
+            label: tip_racks
+          output:
+          - data_key: sources
+            data_source: handle
+            data_type: resource
+            handler_key: targets
+            label: 转移目标
+          - data_key: tip_racks
+            data_source: handle
             data_type: resource
             handler_key: tip_rack
-            label: tip_rack
+            label: 枪头盒
           output:
-          - data_key: liquid
-            data_source: handle
+          - data_key: sources.@flatten
+            data_source: executor
             data_type: resource
             handler_key: sources_out
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets_out
-            label: targets
+            label: 移液后目标孔
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -4764,13 +4812,13 @@ liquid_handler.biomek:
           targets: ''
         handles:
           input:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources
             label: sources
           output:
-          - data_key: liquid
+          - data_key: targets
             data_source: handle
             data_type: resource
             handler_key: targets
@@ -4923,29 +4971,29 @@ liquid_handler.biomek:
           volume: 0.0
         handles:
           input:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets
             label: targets
-          - data_key: liquid
-            data_source: executor
+          - data_key: tip_racks
+            data_source: handle
             data_type: resource
-            handler_key: tip_rack
-            label: tip_rack
+            handler_key: tip_racks
+            label: tip_racks
           output:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources_out
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets_out
             label: targets
@@ -5114,19 +5162,32 @@ liquid_handler.biomek:
           - 0
         handles:
           input:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
-            handler_key: liquid-input
-            io_type: target
-            label: Liquid Input
-          output:
-          - data_key: liquid
-            data_source: executor
+            handler_key: sources
+            label: sources
+          - data_key: targets
+            data_source: handle
             data_type: resource
-            handler_key: liquid-output
-            io_type: source
-            label: Liquid Output
+            handler_key: targets
+            label: targets
+          - data_key: tip_racks
+            data_source: handle
+            data_type: resource
+            handler_key: tip_racks
+            label: tip_racks
+          output:
+          - data_key: sources
+            data_source: handle
+            data_type: resource
+            handler_key: sources_out
+            label: sources
+          - data_key: targets
+            data_source: handle
+            data_type: resource
+            handler_key: targets_out
+            label: targets
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -7604,6 +7665,43 @@ liquid_handler.prcxi:
           title: iter_tips参数
           type: object
         type: UniLabJsonCommand
+      auto-magnetic_action:
+        feedback: {}
+        goal: {}
+        goal_default:
+          height: null
+          is_wait: null
+          module_no: null
+          time: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                height:
+                  type: integer
+                is_wait:
+                  type: boolean
+                module_no:
+                  type: integer
+                time:
+                  type: integer
+              required:
+              - time
+              - module_no
+              - height
+              - is_wait
+              type: object
+            result: {}
+          required:
+          - goal
+          title: magnetic_action参数
+          type: object
+        type: UniLabJsonCommandAsync
       auto-move_to:
         feedback: {}
         goal: {}
@@ -7637,6 +7735,31 @@ liquid_handler.prcxi:
           title: move_to参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-plr_pos_to_prcxi:
+        feedback: {}
+        goal: {}
+        goal_default:
+          resource: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                resource:
+                  type: object
+              required:
+              - resource
+              type: object
+            result: {}
+          required:
+          - goal
+          title: plr_pos_to_prcxi参数
+          type: object
+        type: UniLabJsonCommand
       auto-post_init:
         feedback: {}
         goal: {}
@@ -7757,6 +7880,47 @@ liquid_handler.prcxi:
           title: shaker_action参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-shaking_incubation_action:
+        feedback: {}
+        goal: {}
+        goal_default:
+          amplitude: null
+          is_wait: null
+          module_no: null
+          temperature: null
+          time: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                amplitude:
+                  type: integer
+                is_wait:
+                  type: boolean
+                module_no:
+                  type: integer
+                temperature:
+                  type: integer
+                time:
+                  type: integer
+              required:
+              - time
+              - module_no
+              - amplitude
+              - is_wait
+              - temperature
+              type: object
+            result: {}
+          required:
+          - goal
+          title: shaking_incubation_action参数
+          type: object
+        type: UniLabJsonCommandAsync
       auto-touch_tip:
         feedback: {}
         goal: {}
@@ -8491,7 +8655,19 @@ liquid_handler.prcxi:
                 z: 0.0
             sample_id: ''
             type: ''
-        handles: {}
+        handles:
+          input:
+          - data_key: plate
+            data_source: handle
+            data_type: resource
+            handler_key: plate
+            label: plate
+          output:
+          - data_key: plate
+            data_source: handle
+            data_type: resource
+            handler_key: plate
+            label: plate
         placeholder_keys:
           plate: unilabos_resources
           to: unilabos_resources
@@ -9278,7 +9454,19 @@ liquid_handler.prcxi:
                 z: 0.0
             sample_id: ''
             type: ''
-        handles: {}
+        handles:
+          input:
+          - data_key: wells
+            data_source: handle
+            data_type: resource
+            handler_key: input_wells
+            label: 待设定液体孔
+          output:
+          - data_key: wells.@flatten
+            data_source: executor
+            data_type: resource
+            handler_key: output_wells
+            label: 已设定液体孔
         placeholder_keys:
           wells: unilabos_resources
         result: {}
@@ -9394,6 +9582,165 @@ liquid_handler.prcxi:
           title: LiquidHandlerSetLiquid
           type: object
         type: LiquidHandlerSetLiquid
+      set_liquid_from_plate:
+        feedback: {}
+        goal: {}
+        goal_default:
+          liquid_names: null
+          plate: null
+          volumes: null
+          well_names: null
+        handles:
+          input:
+          - data_key: plate
+            data_source: handle
+            data_type: resource
+            handler_key: input_plate
+            label: 待设定液体板
+          output:
+          - data_key: plate.@flatten
+            data_source: executor
+            data_type: resource
+            handler_key: output_plate
+            label: 已设定液体板
+          - data_key: wells.@flatten
+            data_source: executor
+            data_type: resource
+            handler_key: output_wells
+            label: 已设定液体孔
+          - data_key: volumes
+            data_source: executor
+            data_type: number_array
+            handler_key: output_volumes
+            label: 各孔设定体积
+        placeholder_keys:
+          plate: unilabos_resources
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                liquid_names:
+                  items:
+                    type: string
+                  type: array
+                plate:
+                  items:
+                    properties:
+                      category:
+                        type: string
+                      children:
+                        items:
+                          type: string
+                        type: array
+                      config:
+                        type: string
+                      data:
+                        type: string
+                      id:
+                        type: string
+                      name:
+                        type: string
+                      parent:
+                        type: string
+                      pose:
+                        properties:
+                          orientation:
+                            properties:
+                              w:
+                                type: number
+                              x:
+                                type: number
+                              y:
+                                type: number
+                              z:
+                                type: number
+                            required:
+                            - x
+                            - y
+                            - z
+                            - w
+                            title: orientation
+                            type: object
+                          position:
+                            properties:
+                              x:
+                                type: number
+                              y:
+                                type: number
+                              z:
+                                type: number
+                            required:
+                            - x
+                            - y
+                            - z
+                            title: position
+                            type: object
+                        required:
+                        - position
+                        - orientation
+                        title: pose
+                        type: object
+                      sample_id:
+                        type: string
+                      type:
+                        type: string
+                    required:
+                    - id
+                    - name
+                    - sample_id
+                    - children
+                    - parent
+                    - type
+                    - category
+                    - pose
+                    - config
+                    - data
+                    title: plate
+                    type: object
+                  title: plate
+                  type: array
+                volumes:
+                  items:
+                    type: number
+                  type: array
+                well_names:
+                  items:
+                    type: string
+                  type: array
+              required:
+              - plate
+              - well_names
+              - liquid_names
+              - volumes
+              type: object
+            result:
+              properties:
+                plate:
+                  items: {}
+                  title: Plate
+                  type: array
+                volumes:
+                  items: {}
+                  title: Volumes
+                  type: array
+                wells:
+                  items: {}
+                  title: Wells
+                  type: array
+              required:
+              - plate
+              - wells
+              - volumes
+              title: SetLiquidFromPlateReturn
+              type: object
+          required:
+          - goal
+          title: set_liquid_from_plate参数
+          type: object
+        type: UniLabJsonCommand
       set_tiprack:
         feedback: {}
         goal:
@@ -9739,32 +10086,32 @@ liquid_handler.prcxi:
           - 0
         handles:
           input:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets
             label: targets
-          - data_key: liquid
-            data_source: executor
+          - data_key: tip_racks
+            data_source: handle
             data_type: resource
-            handler_key: tip_rack
-            label: tip_rack
+            handler_key: tip_racks
+            label: tip_racks
           output:
-          - data_key: liquid
+          - data_key: sources
             data_source: handle
             data_type: resource
             handler_key: sources_out
             label: sources
-          - data_key: liquid
-            data_source: executor
+          - data_key: targets
+            data_source: handle
             data_type: resource
             handler_key: targets_out
-            label: targets
+            label: 移液后目标孔
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources
@@ -10145,6 +10492,12 @@ liquid_handler.prcxi:
           type: string
         deck:
           type: object
+        deck_y:
+          default: 400
+          type: string
+        deck_z:
+          default: 300
+          type: string
         host:
           type: string
         is_9320:
@@ -10155,17 +10508,44 @@ liquid_handler.prcxi:
           type: string
         port:
           type: integer
+        rail_interval:
+          default: 0
+          type: string
+        rail_nums:
+          default: 4
+          type: string
+        rail_width:
+          default: 27.5
+          type: string
         setup:
           default: true
           type: string
         simulator:
           default: false
           type: string
+        start_rail:
+          default: 2
+          type: string
         step_mode:
           default: false
           type: string
         timeout:
           type: number
+        x_increase:
+          default: -0.003636
+          type: string
+        x_offset:
+          default: -0.8
+          type: string
+        xy_coupling:
+          default: -0.0045
+          type: string
+        y_increase:
+          default: -0.003636
+          type: string
+        y_offset:
+          default: -37.98
+          type: string
       required:
       - deck
       - host

unilabos/registry/devices/reaction_station_bioyond.yaml

@@ -4,88 +4,213 @@ reaction_station.bioyond:
   - reaction_station_bioyond
   class:
     action_value_mappings:
-      add_time_constraint:
+      auto-create_order:
         feedback: {}
-        goal:
-          duration: duration
-          end_point: end_point
-          end_step_key: end_step_key
-          start_point: start_point
-          start_step_key: start_step_key
+        goal: {}
         goal_default:
-          duration: 0
-          end_point: 0
-          end_step_key: ''
-          start_point: 0
-          start_step_key: ''
+          json_str: null
         handles: {}
+        placeholder_keys: {}
         result: {}
         schema:
-          description: 添加时间约束 - 在两个工作流之间添加时间约束
+          description: ''
           properties:
             feedback: {}
             goal:
               properties:
-                duration:
-                  description: 时间(秒)
-                  type: integer
-                end_point:
-                  default: Start
-                  description: 终点计时点 (Start=开始前, End=结束后)
-                  enum:
-                  - Start
-                  - End
-                  type: string
-                end_step_key:
-                  description: 终点步骤Key (可选, 默认为空则自动选择)
-                  type: string
-                start_point:
-                  default: Start
-                  description: 起点计时点 (Start=开始前, End=结束后)
-                  enum:
-                  - Start
-                  - End
-                  type: string
-                start_step_key:
-                  description: 起点步骤Key (例如 "feeding", "liquid", 可选, 默认为空则自动选择)
+                json_str:
                   type: string
               required:
-              - duration
+              - json_str
               type: object
             result: {}
           required:
           - goal
-          title: add_time_constraint参数
+          title: create_order参数
           type: object
         type: UniLabJsonCommand
-      clean_all_server_workflows:
+      auto-hard_delete_merged_workflows:
         feedback: {}
         goal: {}
-        goal_default: {}
+        goal_default:
+          workflow_ids: null
         handles: {}
-        result:
-          code: code
-          message: message
+        placeholder_keys: {}
+        result: {}
         schema:
-          description: 清空服务端所有非核心工作流 (保留核心流程)
+          description: ''
           properties:
             feedback: {}
             goal:
-              properties: {}
-              required: []
-              type: object
-            result:
               properties:
-                code:
-                  description: 操作结果代码(1表示成功)
-                  type: integer
-                message:
-                  description: 结果描述
-                  type: string
+                workflow_ids:
+                  items:
+                    type: string
+                  type: array
+              required:
+              - workflow_ids
               type: object
+            result: {}
           required:
           - goal
-          title: clean_all_server_workflows参数
+          title: hard_delete_merged_workflows参数
+          type: object
+        type: UniLabJsonCommand
+      auto-merge_workflow_with_parameters:
+        feedback: {}
+        goal: {}
+        goal_default:
+          json_str: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                json_str:
+                  type: string
+              required:
+              - json_str
+              type: object
+            result: {}
+          required:
+          - goal
+          title: merge_workflow_with_parameters参数
+          type: object
+        type: UniLabJsonCommand
+      auto-process_temperature_cutoff_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          report_request: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                report_request:
+                  type: string
+              required:
+              - report_request
+              type: object
+            result: {}
+          required:
+          - goal
+          title: process_temperature_cutoff_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-process_web_workflows:
+        feedback: {}
+        goal: {}
+        goal_default:
+          web_workflow_json: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                web_workflow_json:
+                  type: string
+              required:
+              - web_workflow_json
+              type: object
+            result: {}
+          required:
+          - goal
+          title: process_web_workflows参数
+          type: object
+        type: UniLabJsonCommand
+      auto-skip_titration_steps:
+        feedback: {}
+        goal: {}
+        goal_default:
+          preintake_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                preintake_id:
+                  type: string
+              required:
+              - preintake_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: skip_titration_steps参数
+          type: object
+        type: UniLabJsonCommand
+      auto-wait_for_multiple_orders_and_get_reports:
+        feedback: {}
+        goal: {}
+        goal_default:
+          batch_create_result: null
+          check_interval: 10
+          timeout: 7200
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                batch_create_result:
+                  type: string
+                check_interval:
+                  default: 10
+                  type: integer
+                timeout:
+                  default: 7200
+                  type: integer
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: wait_for_multiple_orders_and_get_reports参数
+          type: object
+        type: UniLabJsonCommand
+      auto-workflow_step_query:
+        feedback: {}
+        goal: {}
+        goal_default:
+          workflow_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                workflow_id:
+                  type: string
+              required:
+              - workflow_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: workflow_step_query参数
           type: object
         type: UniLabJsonCommand
       drip_back:
@@ -122,19 +247,13 @@ reaction_station.bioyond:
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                   type: string
                 torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                   type: string
                 volume:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                   type: string
               required:
               - volume
@@ -234,19 +353,13 @@ reaction_station.bioyond:
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                   type: string
                 torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                   type: string
                 volume:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                   type: string
               required:
               - volume
@@ -290,7 +403,7 @@ reaction_station.bioyond:
             label: Solvents Data From Calculation Node
         result: {}
         schema:
-          description: 液体投料-溶剂。可以直接提供volume(mL),或通过solvents对象自动从additional_solvent(mL)计算volume。
+          description: 液体投料-溶剂。可以直接提供volume(μL),或通过solvents对象自动从additional_solvent(mL)计算volume。
           properties:
             feedback: {}
             goal:
@@ -310,21 +423,15 @@ reaction_station.bioyond:
                   description: 观察时间(分钟),默认360
                   type: string
                 titration_type:
-                  default: 'NO'
-                  description: 是否滴定(NO=否, YES=是),默认NO
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '1'
+                  description: 是否滴定(1=否, 2=是),默认1
                   type: string
                 torque_variation:
-                  default: 'YES'
-                  description: 是否观察 (NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否观察 (1=否, 2=是),默认2
                   type: string
                 volume:
-                  description: 分液量(mL)。可直接提供,或通过solvents参数自动计算
+                  description: 分液量(μL)。可直接提供,或通过solvents参数自动计算
                   type: string
               required:
               - assign_material_name
@@ -397,21 +504,15 @@ reaction_station.bioyond:
                   description: 观察时间(分钟),默认90
                   type: string
                 titration_type:
-                  default: 'YES'
-                  description: 是否滴定(NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否滴定(1=否, 2=是),默认2
                   type: string
                 torque_variation:
-                  default: 'YES'
-                  description: 是否观察 (NO=否, YES=是),默认YES
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  default: '2'
+                  description: 是否观察 (1=否, 2=是),默认2
                   type: string
                 volume_formula:
-                  description: 分液公式(mL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
+                  description: 分液公式(μL)。可直接提供固定公式,或留空由系统根据x_value、feeding_order_data、extracted_actuals自动生成
                   type: string
                 x_value:
                   description: 公式中的x值,手工输入,格式为"{{1-2-3}}"(包含双花括号)。用于自动公式计算
@@ -459,19 +560,13 @@ reaction_station.bioyond:
                   description: 观察时间(分钟)
                   type: string
                 titration_type:
-                  description: 是否滴定(NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否滴定(1=否, 2=是)
                   type: string
                 torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                   type: string
                 volume_formula:
-                  description: 分液公式(mL)
+                  description: 分液公式(μL)
                   type: string
               required:
               - volume_formula
@@ -585,35 +680,6 @@ reaction_station.bioyond:
           title: reactor_taken_out参数
           type: object
         type: UniLabJsonCommand
-      scheduler_start:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: 启动调度器 - 启动Bioyond工作站的任务调度器，开始执行队列中的任务
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                return_info:
-                  description: 调度器启动结果，成功返回1，失败返回0
-                  type: integer
-              required:
-              - return_info
-              title: scheduler_start结果
-              type: object
-          required:
-          - goal
-          title: scheduler_start参数
-          type: object
-        type: UniLabJsonCommand
       solid_feeding_vials:
         feedback: {}
         goal:
@@ -640,11 +706,7 @@ reaction_station.bioyond:
                   description: 物料名称(用于获取试剂瓶位ID)
                   type: string
                 material_id:
-                  description: 粉末类型ID，Salt=盐（21分钟），Flour=面粉（27分钟），BTDA=BTDA（38分钟）
-                  enum:
-                  - Salt
-                  - Flour
-                  - BTDA
+                  description: 粉末类型ID，1=盐（21分钟），2=面粉（27分钟），3=BTDA（38分钟）
                   type: string
                 temperature:
                   description: 温度设定(°C)
@@ -653,10 +715,7 @@ reaction_station.bioyond:
                   description: 观察时间(分钟)
                   type: string
                 torque_variation:
-                  description: 是否观察 (NO=否, YES=是)
-                  enum:
-                  - 'NO'
-                  - 'YES'
+                  description: 是否观察 (1=否, 2=是)
                   type: string
               required:
               - assign_material_name
@@ -674,16 +733,6 @@ reaction_station.bioyond:
     module: unilabos.devices.workstation.bioyond_studio.reaction_station:BioyondReactionStation
     protocol_type: []
     status_types:
-      average_viscosity: Float64
-      force: Float64
-      in_temperature: Float64
-      out_temperature: Float64
-      pt100_temperature: Float64
-      sensor_average_temperature: Float64
-      setting_temperature: Float64
-      speed: Float64
-      target_temperature: Float64
-      viscosity: Float64
       workflow_sequence: String
     type: python
   config_info: []
@@ -716,19 +765,34 @@ reaction_station.reactor:
   - reactor
   - reaction_station_bioyond
   class:
-    action_value_mappings: {}
+    action_value_mappings:
+      auto-update_metrics:
+        feedback: {}
+        goal: {}
+        goal_default:
+          payload: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                payload:
+                  type: object
+              required:
+              - payload
+              type: object
+            result: {}
+          required:
+          - goal
+          title: update_metrics参数
+          type: object
+        type: UniLabJsonCommand
     module: unilabos.devices.workstation.bioyond_studio.reaction_station:BioyondReactor
-    status_types:
-      average_viscosity: Float64
-      force: Float64
-      in_temperature: Float64
-      out_temperature: Float64
-      pt100_temperature: Float64
-      sensor_average_temperature: Float64
-      setting_temperature: Float64
-      speed: Float64
-      target_temperature: Float64
-      viscosity: Float64
+    status_types: {}
     type: python
   config_info: []
   description: 反应站子设备-反应器

unilabos/registry/devices/virtual_device.yaml

@@ -5792,3 +5792,381 @@ virtual_vacuum_pump:
       - status
       type: object
   version: 1.0.0
+virtual_workbench:
+  category:
+  - virtual_device
+  class:
+    action_value_mappings:
+      auto-move_to_heating_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_number: null
+        handles:
+          input:
+          - data_key: material_number
+            data_source: handle
+            data_type: workbench_material
+            handler_key: material_input
+            label: 物料编号
+          output:
+          - data_key: station_id
+            data_source: executor
+            data_type: workbench_station
+            handler_key: heating_station_output
+            label: 加热台ID
+          - data_key: material_number
+            data_source: executor
+            data_type: workbench_material
+            handler_key: material_number_output
+            label: 物料编号
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 将物料从An位置移动到空闲加热台，返回分配的加热台ID
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_number:
+                  description: 物料编号，1-5，物料ID自动生成为A{n}
+                  type: integer
+              required:
+              - material_number
+              type: object
+            result:
+              description: move_to_heating_station 返回类型
+              properties:
+                material_id:
+                  title: Material Id
+                  type: string
+                material_number:
+                  title: Material Number
+                  type: integer
+                message:
+                  title: Message
+                  type: string
+                station_id:
+                  description: 分配的加热台ID
+                  title: Station Id
+                  type: integer
+                success:
+                  title: Success
+                  type: boolean
+              required:
+              - success
+              - station_id
+              - material_id
+              - material_number
+              - message
+              title: MoveToHeatingStationResult
+              type: object
+          required:
+          - goal
+          title: move_to_heating_station参数
+          type: object
+        type: UniLabJsonCommand
+      auto-move_to_output:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_number: null
+          station_id: null
+        handles:
+          input:
+          - data_key: station_id
+            data_source: handle
+            data_type: workbench_station
+            handler_key: output_station_input
+            label: 加热台ID
+          - data_key: material_number
+            data_source: handle
+            data_type: workbench_material
+            handler_key: output_material_input
+            label: 物料编号
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 将物料从加热台移动到输出位置Cn
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_number:
+                  description: 物料编号，用于确定输出位置Cn
+                  type: integer
+                station_id:
+                  description: 加热台ID，1-3，从上一节点传入
+                  type: integer
+              required:
+              - station_id
+              - material_number
+              type: object
+            result:
+              description: move_to_output 返回类型
+              properties:
+                material_id:
+                  title: Material Id
+                  type: string
+                station_id:
+                  title: Station Id
+                  type: integer
+                success:
+                  title: Success
+                  type: boolean
+              required:
+              - success
+              - station_id
+              - material_id
+              title: MoveToOutputResult
+              type: object
+          required:
+          - goal
+          title: move_to_output参数
+          type: object
+        type: UniLabJsonCommand
+      auto-prepare_materials:
+        feedback: {}
+        goal: {}
+        goal_default:
+          count: 5
+        handles:
+          output:
+          - data_key: material_1
+            data_source: executor
+            data_type: workbench_material
+            handler_key: channel_1
+            label: 实验1
+          - data_key: material_2
+            data_source: executor
+            data_type: workbench_material
+            handler_key: channel_2
+            label: 实验2
+          - data_key: material_3
+            data_source: executor
+            data_type: workbench_material
+            handler_key: channel_3
+            label: 实验3
+          - data_key: material_4
+            data_source: executor
+            data_type: workbench_material
+            handler_key: channel_4
+            label: 实验4
+          - data_key: material_5
+            data_source: executor
+            data_type: workbench_material
+            handler_key: channel_5
+            label: 实验5
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 批量准备物料 - 虚拟起始节点，生成A1-A5物料，输出5个handle供后续节点使用
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                count:
+                  default: 5
+                  description: 待生成的物料数量，默认5 (生成 A1-A5)
+                  type: integer
+              required: []
+              type: object
+            result:
+              description: prepare_materials 返回类型 - 批量准备物料
+              properties:
+                count:
+                  title: Count
+                  type: integer
+                material_1:
+                  title: Material 1
+                  type: integer
+                material_2:
+                  title: Material 2
+                  type: integer
+                material_3:
+                  title: Material 3
+                  type: integer
+                material_4:
+                  title: Material 4
+                  type: integer
+                material_5:
+                  title: Material 5
+                  type: integer
+                message:
+                  title: Message
+                  type: string
+                success:
+                  title: Success
+                  type: boolean
+              required:
+              - success
+              - count
+              - material_1
+              - material_2
+              - material_3
+              - material_4
+              - material_5
+              - message
+              title: PrepareMaterialsResult
+              type: object
+          required:
+          - goal
+          title: prepare_materials参数
+          type: object
+        type: UniLabJsonCommand
+      auto-start_heating:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_number: null
+          station_id: null
+        handles:
+          input:
+          - data_key: station_id
+            data_source: handle
+            data_type: workbench_station
+            handler_key: station_id_input
+            label: 加热台ID
+          - data_key: material_number
+            data_source: handle
+            data_type: workbench_material
+            handler_key: material_number_input
+            label: 物料编号
+          output:
+          - data_key: station_id
+            data_source: executor
+            data_type: workbench_station
+            handler_key: heating_done_station
+            label: 加热完成-加热台ID
+          - data_key: material_number
+            data_source: executor
+            data_type: workbench_material
+            handler_key: heating_done_material
+            label: 加热完成-物料编号
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 启动指定加热台的加热程序
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_number:
+                  description: 物料编号，从上一节点传入
+                  type: integer
+                station_id:
+                  description: 加热台ID，1-3，从上一节点传入
+                  type: integer
+              required:
+              - station_id
+              - material_number
+              type: object
+            result:
+              description: start_heating 返回类型
+              properties:
+                material_id:
+                  title: Material Id
+                  type: string
+                material_number:
+                  title: Material Number
+                  type: integer
+                message:
+                  title: Message
+                  type: string
+                station_id:
+                  title: Station Id
+                  type: integer
+                success:
+                  title: Success
+                  type: boolean
+              required:
+              - success
+              - station_id
+              - material_id
+              - material_number
+              - message
+              title: StartHeatingResult
+              type: object
+          required:
+          - goal
+          title: start_heating参数
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.devices.virtual.workbench:VirtualWorkbench
+    status_types:
+      active_tasks_count: int
+      arm_current_task: str
+      arm_state: str
+      heating_station_1_material: str
+      heating_station_1_progress: float
+      heating_station_1_state: str
+      heating_station_2_material: str
+      heating_station_2_progress: float
+      heating_station_2_state: str
+      heating_station_3_material: str
+      heating_station_3_progress: float
+      heating_station_3_state: str
+      message: str
+      status: str
+    type: python
+  config_info: []
+  description: Virtual Workbench with 1 robotic arm and 3 heating stations for concurrent
+    material processing
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        config:
+          type: string
+        device_id:
+          type: string
+      required: []
+      type: object
+    data:
+      properties:
+        active_tasks_count:
+          type: integer
+        arm_current_task:
+          type: string
+        arm_state:
+          type: string
+        heating_station_1_material:
+          type: string
+        heating_station_1_progress:
+          type: number
+        heating_station_1_state:
+          type: string
+        heating_station_2_material:
+          type: string
+        heating_station_2_progress:
+          type: number
+        heating_station_2_state:
+          type: string
+        heating_station_3_material:
+          type: string
+        heating_station_3_progress:
+          type: number
+        heating_station_3_state:
+          type: string
+        message:
+          type: string
+        status:
+          type: string
+      required:
+      - status
+      - arm_state
+      - arm_current_task
+      - heating_station_1_state
+      - heating_station_1_material
+      - heating_station_1_progress
+      - heating_station_2_state
+      - heating_station_2_material
+      - heating_station_2_progress
+      - heating_station_3_state
+      - heating_station_3_material
+      - heating_station_3_progress
+      - active_tasks_count
+      - message
+      type: object
+  version: 1.0.0

unilabos/registry/registry.py

@@ -4,6 +4,8 @@ import os
 import sys
 import inspect
 import importlib
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Dict, List, Union, Tuple
 
@@ -60,6 +62,7 @@ class Registry:
         self.device_module_to_registry = {}
         self.resource_type_registry = {}
         self._setup_called = False  # 跟踪setup是否已调用
+        self._registry_lock = threading.Lock()  # 多线程加载时的锁
         # 其他状态变量
         # self.is_host_mode = False  # 移至BasicConfig中
 
@@ -71,6 +74,20 @@ class Registry:
 
         from unilabos.app.web.utils.action_utils import get_yaml_from_goal_type
 
+        # 获取 HostNode 类的增强信息，用于自动生成 action schema
+        host_node_enhanced_info = get_enhanced_class_info(
+            "unilabos.ros.nodes.presets.host_node:HostNode", use_dynamic=True
+        )
+
+        # 为 test_latency 生成 schema，保留原有 description
+        test_latency_method_info = host_node_enhanced_info.get("action_methods", {}).get("test_latency", {})
+        test_latency_schema = self._generate_unilab_json_command_schema(
+            test_latency_method_info.get("args", []),
+            "test_latency",
+            test_latency_method_info.get("return_annotation"),
+        )
+        test_latency_schema["description"] = "用于测试延迟的动作，返回延迟时间和时间差。"
+
         self.device_type_registry.update(
             {
                 "host_node": {
@@ -124,28 +141,47 @@ class Registry:
                                     "output": [
                                         {
                                             "handler_key": "labware",
-                                            "label": "Labware",
                                             "data_type": "resource",
-                                            "data_source": "handle",
-                                            "data_key": "liquid",
-                                        }
+                                            "label": "Labware",
+                                            "data_source": "executor",
+                                            "data_key": "created_resource_tree.@flatten",
+                                        },
+                                        {
+                                            "handler_key": "liquid_slots",
+                                            "data_type": "resource",
+                                            "label": "LiquidSlots",
+                                            "data_source": "executor",
+                                            "data_key": "liquid_input_resource_tree.@flatten",
+                                        },
+                                        {
+                                            "handler_key": "materials",
+                                            "data_type": "resource",
+                                            "label": "AllMaterials",
+                                            "data_source": "executor",
+                                            "data_key": "[created_resource_tree,liquid_input_resource_tree].@flatten.@flatten",
+                                        },
                                     ]
                                 },
                                 "placeholder_keys": {
                                     "res_id": "unilabos_resources",  # 将当前实验室的全部物料id作为下拉框可选择
                                     "device_id": "unilabos_devices",  # 将当前实验室的全部设备id作为下拉框可选择
                                     "parent": "unilabos_nodes",  # 将当前实验室的设备/物料作为下拉框可选择
+                                    "class_name": "unilabos_class",
                                 },
                             },
                             "test_latency": {
-                                "type": self.EmptyIn,
+                                "type": (
+                                    "UniLabJsonCommandAsync"
+                                    if test_latency_method_info.get("is_async", False)
+                                    else "UniLabJsonCommand"
+                                ),
                                 "goal": {},
                                 "feedback": {},
                                 "result": {},
-                                "schema": ros_action_to_json_schema(
-                                    self.EmptyIn, "用于测试延迟的动作，返回延迟时间和时间差。"
-                                ),
-                                "goal_default": {},
+                                "schema": test_latency_schema,
+                                "goal_default": {
+                                    arg["name"]: arg["default"] for arg in test_latency_method_info.get("args", [])
+                                },
                                 "handles": {},
                             },
                             "auto-test_resource": {
@@ -186,7 +222,17 @@ class Registry:
                                     "resources": "unilabos_resources",
                                 },
                                 "goal_default": {},
-                                "handles": {},
+                                "handles": {
+                                    "input": [
+                                        {
+                                            "handler_key": "input_resources",
+                                            "data_type": "resource",
+                                            "label": "InputResources",
+                                            "data_source": "handle",
+                                            "data_key": "resources",  # 不为空
+                                        },
+                                    ]
+                                },
                             },
                         },
                     },
@@ -218,67 +264,115 @@ class Registry:
         # 标记setup已被调用
         self._setup_called = True
 
+    def _load_single_resource_file(
+        self, file: Path, complete_registry: bool, upload_registry: bool
+    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool]:
+        """
+        加载单个资源文件 (线程安全)
+
+        Returns:
+            (data, complete_data, is_valid): 资源数据, 完整数据, 是否有效
+        """
+        try:
+            with open(file, encoding="utf-8", mode="r") as f:
+                data = yaml.safe_load(io.StringIO(f.read()))
+        except Exception as e:
+            logger.warning(f"[UniLab Registry] 读取资源文件失败: {file}, 错误: {e}")
+            return {}, {}, False
+
+        if not data:
+            return {}, {}, False
+
+        complete_data = {}
+        for resource_id, resource_info in data.items():
+            if "version" not in resource_info:
+                resource_info["version"] = "1.0.0"
+            if "category" not in resource_info:
+                resource_info["category"] = [file.stem]
+            elif file.stem not in resource_info["category"]:
+                resource_info["category"].append(file.stem)
+            elif not isinstance(resource_info.get("category"), list):
+                resource_info["category"] = [resource_info["category"]]
+            if "config_info" not in resource_info:
+                resource_info["config_info"] = []
+            if "icon" not in resource_info:
+                resource_info["icon"] = ""
+            if "handles" not in resource_info:
+                resource_info["handles"] = []
+            if "init_param_schema" not in resource_info:
+                resource_info["init_param_schema"] = {}
+            if "config_info" in resource_info:
+                del resource_info["config_info"]
+            if "file_path" in resource_info:
+                del resource_info["file_path"]
+            complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
+            if upload_registry:
+                class_info = resource_info.get("class", {})
+                if len(class_info) and "module" in class_info:
+                    if class_info.get("type") == "pylabrobot":
+                        res_class = get_class(class_info["module"])
+                        if callable(res_class) and not isinstance(res_class, type):
+                            res_instance = res_class(res_class.__name__)
+                            res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
+                            resource_info["config_info"] = res_ulr
+            resource_info["registry_type"] = "resource"
+            resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
+
+        complete_data = dict(sorted(complete_data.items()))
+        complete_data = copy.deepcopy(complete_data)
+
+        if complete_registry:
+            try:
+                with open(file, "w", encoding="utf-8") as f:
+                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+            except Exception as e:
+                logger.warning(f"[UniLab Registry] 写入资源文件失败: {file}, 错误: {e}")
+
+        return data, complete_data, True
+
     def load_resource_types(self, path: os.PathLike, complete_registry: bool, upload_registry: bool):
         abs_path = Path(path).absolute()
         resource_path = abs_path / "resources"
         files = list(resource_path.glob("*/*.yaml"))
-        logger.trace(f"[UniLab Registry] load resources? {resource_path.exists()}, total: {len(files)}")
-        current_resource_number = len(self.resource_type_registry) + 1
-        for i, file in enumerate(files):
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-            complete_data = {}
-            if data:
-                # 为每个资源添加文件路径信息
-                for resource_id, resource_info in data.items():
-                    if "version" not in resource_info:
-                        resource_info["version"] = "1.0.0"
-                    if "category" not in resource_info:
-                        resource_info["category"] = [file.stem]
-                    elif file.stem not in resource_info["category"]:
-                        resource_info["category"].append(file.stem)
-                    elif not isinstance(resource_info.get("category"), list):
-                        resource_info["category"] = [resource_info["category"]]
-                    if "config_info" not in resource_info:
-                        resource_info["config_info"] = []
-                    if "icon" not in resource_info:
-                        resource_info["icon"] = ""
-                    if "handles" not in resource_info:
-                        resource_info["handles"] = []
-                    if "init_param_schema" not in resource_info:
-                        resource_info["init_param_schema"] = {}
-                    if "config_info" in resource_info:
-                        del resource_info["config_info"]
-                    if "file_path" in resource_info:
-                        del resource_info["file_path"]
-                    complete_data[resource_id] = copy.deepcopy(dict(sorted(resource_info.items())))
-                    if upload_registry:
-                        class_info = resource_info.get("class", {})
-                        if len(class_info) and "module" in class_info:
-                            if class_info.get("type") == "pylabrobot":
-                                res_class = get_class(class_info["module"])
-                                if callable(res_class) and not isinstance(
-                                    res_class, type
-                                ):  # 有的是类，有的是函数，这里暂时只登记函数类的
-                                    res_instance = res_class(res_class.__name__)
-                                    res_ulr = tree_to_list([resource_plr_to_ulab(res_instance)])
-                                    resource_info["config_info"] = res_ulr
-                    resource_info["registry_type"] = "resource"
-                    resource_info["file_path"] = str(file.absolute()).replace("\\", "/")
-                complete_data = dict(sorted(complete_data.items()))
-                complete_data = copy.deepcopy(complete_data)
-                if complete_registry:
-                    with open(file, "w", encoding="utf-8") as f:
-                        yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+        logger.debug(f"[UniLab Registry] resources: {resource_path.exists()}, total: {len(files)}")
 
+        if not files:
+            return
+
+        # 使用线程池并行加载
+        max_workers = min(8, len(files))
+        results = []
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {
+                executor.submit(self._load_single_resource_file, file, complete_registry, upload_registry): file
+                for file in files
+            }
+            for future in as_completed(future_to_file):
+                file = future_to_file[future]
+                try:
+                    data, complete_data, is_valid = future.result()
+                    if is_valid:
+                        results.append((file, data))
+                except Exception as e:
+                    logger.warning(f"[UniLab Registry] 处理资源文件异常: {file}, 错误: {e}")
+
+        # 线程安全地更新注册表
+        current_resource_number = len(self.resource_type_registry) + 1
+        with self._registry_lock:
+            for i, (file, data) in enumerate(results):
                 self.resource_type_registry.update(data)
-                logger.trace(  # type: ignore
-                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(files)} "
+                logger.trace(
+                    f"[UniLab Registry] Resource-{current_resource_number} File-{i+1}/{len(results)} "
                     + f"Add {list(data.keys())}"
                 )
                 current_resource_number += 1
-            else:
-                logger.debug(f"[UniLab Registry] Res File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}")
+
+        # 记录无效文件
+        valid_files = {r[0] for r in results}
+        for file in files:
+            if file not in valid_files:
+                logger.debug(f"[UniLab Registry] Res File Not Valid YAML File: {file.absolute()}")
 
     def _extract_class_docstrings(self, module_string: str) -> Dict[str, str]:
         """
@@ -455,7 +549,11 @@ class Registry:
         return status_schema
 
     def _generate_unilab_json_command_schema(
-        self, method_args: List[Dict[str, Any]], method_name: str, return_annotation: Any = None
+        self,
+        method_args: List[Dict[str, Any]],
+        method_name: str,
+        return_annotation: Any = None,
+        previous_schema: Dict[str, Any] | None = None,
     ) -> Dict[str, Any]:
         """
         根据UniLabJsonCommand方法信息生成JSON Schema，暂不支持嵌套类型
@@ -464,6 +562,7 @@ class Registry:
             method_args: 方法信息字典，包含args等
             method_name: 方法名称
             return_annotation: 返回类型注解，用于生成result schema（仅支持TypedDict）
+            previous_schema: 之前的 schema，用于保留 goal/feedback/result 下一级字段的 description
 
         Returns:
             JSON Schema格式的参数schema
@@ -497,7 +596,7 @@ class Registry:
         if return_annotation is not None and self._is_typed_dict(return_annotation):
             result_schema = self._generate_typed_dict_result_schema(return_annotation)
 
-        return {
+        final_schema = {
             "title": f"{method_name}参数",
             "description": f"",
             "type": "object",
@@ -505,6 +604,40 @@ class Registry:
             "required": ["goal"],
         }
 
+        # 保留之前 schema 中 goal/feedback/result 下一级字段的 description
+        if previous_schema:
+            self._preserve_field_descriptions(final_schema, previous_schema)
+
+        return final_schema
+
+    def _preserve_field_descriptions(self, new_schema: Dict[str, Any], previous_schema: Dict[str, Any]) -> None:
+        """
+        保留之前 schema 中 goal/feedback/result 下一级字段的 description 和 title
+
+        Args:
+            new_schema: 新生成的 schema（会被修改）
+            previous_schema: 之前的 schema
+        """
+        for section in ["goal", "feedback", "result"]:
+            new_section = new_schema.get("properties", {}).get(section, {})
+            prev_section = previous_schema.get("properties", {}).get(section, {})
+
+            if not new_section or not prev_section:
+                continue
+
+            new_props = new_section.get("properties", {})
+            prev_props = prev_section.get("properties", {})
+
+            for field_name, field_schema in new_props.items():
+                if field_name in prev_props:
+                    prev_field = prev_props[field_name]
+                    # 保留字段的 description
+                    if "description" in prev_field and prev_field["description"]:
+                        field_schema["description"] = prev_field["description"]
+                    # 保留字段的 title（用户自定义的中文名）
+                    if "title" in prev_field and prev_field["title"]:
+                        field_schema["title"] = prev_field["title"]
+
     def _is_typed_dict(self, annotation: Any) -> bool:
         """
         检查类型注解是否是TypedDict
@@ -591,209 +724,244 @@ class Registry:
                 "handles": {},
             }
 
+    def _load_single_device_file(
+        self, file: Path, complete_registry: bool, get_yaml_from_goal_type
+    ) -> Tuple[Dict[str, Any], Dict[str, Any], bool, List[str]]:
+        """
+        加载单个设备文件 (线程安全)
+
+        Returns:
+            (data, complete_data, is_valid, device_ids): 设备数据, 完整数据, 是否有效, 设备ID列表
+        """
+        try:
+            with open(file, encoding="utf-8", mode="r") as f:
+                data = yaml.safe_load(io.StringIO(f.read()))
+        except Exception as e:
+            logger.warning(f"[UniLab Registry] 读取设备文件失败: {file}, 错误: {e}")
+            return {}, {}, False, []
+
+        if not data:
+            return {}, {}, False, []
+
+        complete_data = {}
+        action_str_type_mapping = {
+            "UniLabJsonCommand": "UniLabJsonCommand",
+            "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
+        }
+        status_str_type_mapping = {}
+        device_ids = []
+
+        for device_id, device_config in data.items():
+            if "version" not in device_config:
+                device_config["version"] = "1.0.0"
+            if "category" not in device_config:
+                device_config["category"] = [file.stem]
+            elif file.stem not in device_config["category"]:
+                device_config["category"].append(file.stem)
+            if "config_info" not in device_config:
+                device_config["config_info"] = []
+            if "description" not in device_config:
+                device_config["description"] = ""
+            if "icon" not in device_config:
+                device_config["icon"] = ""
+            if "handles" not in device_config:
+                device_config["handles"] = []
+            if "init_param_schema" not in device_config:
+                device_config["init_param_schema"] = {}
+            if "class" in device_config:
+                if "status_types" not in device_config["class"] or device_config["class"]["status_types"] is None:
+                    device_config["class"]["status_types"] = {}
+                if (
+                    "action_value_mappings" not in device_config["class"]
+                    or device_config["class"]["action_value_mappings"] is None
+                ):
+                    device_config["class"]["action_value_mappings"] = {}
+                enhanced_info = {}
+                if complete_registry:
+                    device_config["class"]["status_types"].clear()
+                    enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
+                    if not enhanced_info.get("dynamic_import_success", False):
+                        continue
+                    device_config["class"]["status_types"].update(
+                        {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
+                    )
+                for status_name, status_type in device_config["class"]["status_types"].items():
+                    if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
+                        status_type = "String"
+                        device_config["class"]["status_types"][status_name] = status_type
+                    try:
+                        target_type = self._replace_type_with_class(status_type, device_id, f"状态 {status_name}")
+                    except ROSMsgNotFound:
+                        continue
+                    if target_type in [dict, list]:
+                        target_type = String
+                    status_str_type_mapping[status_type] = target_type
+                device_config["class"]["status_types"] = dict(sorted(device_config["class"]["status_types"].items()))
+                if complete_registry:
+                    old_action_configs = {}
+                    for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                        old_action_configs[action_name] = action_config
+
+                    device_config["class"]["action_value_mappings"] = {
+                        k: v
+                        for k, v in device_config["class"]["action_value_mappings"].items()
+                        if not k.startswith("auto-")
+                    }
+                    device_config["class"]["action_value_mappings"].update(
+                        {
+                            f"auto-{k}": {
+                                "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
+                                "goal": {},
+                                "feedback": {},
+                                "result": {},
+                                "schema": self._generate_unilab_json_command_schema(
+                                    v["args"],
+                                    k,
+                                    v.get("return_annotation"),
+                                    old_action_configs.get(f"auto-{k}", {}).get("schema"),
+                                ),
+                                "goal_default": {i["name"]: i["default"] for i in v["args"]},
+                                "handles": old_action_configs.get(f"auto-{k}", {}).get("handles", []),
+                                "placeholder_keys": {
+                                    i["name"]: (
+                                        "unilabos_resources"
+                                        if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
+                                        or i["type"] == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
+                                        else "unilabos_devices"
+                                    )
+                                    for i in v["args"]
+                                    if i.get("type", "")
+                                    in [
+                                        "unilabos.registry.placeholder_type:ResourceSlot",
+                                        "unilabos.registry.placeholder_type:DeviceSlot",
+                                        ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
+                                        ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
+                                    ]
+                                },
+                            }
+                            for k, v in enhanced_info["action_methods"].items()
+                            if k not in device_config["class"]["action_value_mappings"]
+                        }
+                    )
+                    for action_name, old_config in old_action_configs.items():
+                        if action_name in device_config["class"]["action_value_mappings"]:
+                            old_schema = old_config.get("schema", {})
+                            if "description" in old_schema and old_schema["description"]:
+                                device_config["class"]["action_value_mappings"][action_name]["schema"][
+                                    "description"
+                                ] = old_schema["description"]
+                    device_config["init_param_schema"] = {}
+                    device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
+                        enhanced_info["init_params"], "__init__"
+                    )["properties"]["goal"]
+                    device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
+                        enhanced_info["status_methods"]
+                    )
+
+                device_config.pop("schema", None)
+                device_config["class"]["action_value_mappings"] = dict(
+                    sorted(device_config["class"]["action_value_mappings"].items())
+                )
+                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                    if "handles" not in action_config:
+                        action_config["handles"] = {}
+                    elif isinstance(action_config["handles"], list):
+                        if len(action_config["handles"]):
+                            logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
+                            continue
+                        else:
+                            action_config["handles"] = {}
+                    if "type" in action_config:
+                        action_type_str: str = action_config["type"]
+                        if not action_type_str.startswith("UniLabJsonCommand"):
+                            try:
+                                target_type = self._replace_type_with_class(
+                                    action_type_str, device_id, f"动作 {action_name}"
+                                )
+                            except ROSMsgNotFound:
+                                continue
+                            action_str_type_mapping[action_type_str] = target_type
+                            if target_type is not None:
+                                action_config["goal_default"] = yaml.safe_load(
+                                    io.StringIO(get_yaml_from_goal_type(target_type.Goal))
+                                )
+                                action_config["schema"] = ros_action_to_json_schema(target_type)
+                            else:
+                                logger.warning(
+                                    f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
+                                )
+                complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))
+                for status_name, status_type in device_config["class"]["status_types"].items():
+                    device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
+                for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                    if action_config["type"] not in action_str_type_mapping:
+                        continue
+                    action_config["type"] = action_str_type_mapping[action_config["type"]]
+                self._add_builtin_actions(device_config, device_id)
+            device_config["file_path"] = str(file.absolute()).replace("\\", "/")
+            device_config["registry_type"] = "device"
+            device_ids.append(device_id)
+
+        complete_data = dict(sorted(complete_data.items()))
+        complete_data = copy.deepcopy(complete_data)
+        try:
+            with open(file, "w", encoding="utf-8") as f:
+                yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
+        except Exception as e:
+            logger.warning(f"[UniLab Registry] 写入设备文件失败: {file}, 错误: {e}")
+
+        return data, complete_data, True, device_ids
+
     def load_device_types(self, path: os.PathLike, complete_registry: bool):
-        # return
         abs_path = Path(path).absolute()
         devices_path = abs_path / "devices"
         device_comms_path = abs_path / "device_comms"
         files = list(devices_path.glob("*.yaml")) + list(device_comms_path.glob("*.yaml"))
-        logger.trace(  # type: ignore
+        logger.trace(
             f"[UniLab Registry] devices: {devices_path.exists()}, device_comms: {device_comms_path.exists()}, "
             + f"total: {len(files)}"
         )
-        current_device_number = len(self.device_type_registry) + 1
+
+        if not files:
+            return
+
         from unilabos.app.web.utils.action_utils import get_yaml_from_goal_type
 
-        for i, file in enumerate(files):
-            with open(file, encoding="utf-8", mode="r") as f:
-                data = yaml.safe_load(io.StringIO(f.read()))
-            complete_data = {}
-            action_str_type_mapping = {
-                "UniLabJsonCommand": "UniLabJsonCommand",
-                "UniLabJsonCommandAsync": "UniLabJsonCommandAsync",
+        # 使用线程池并行加载
+        max_workers = min(8, len(files))
+        results = []
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {
+                executor.submit(self._load_single_device_file, file, complete_registry, get_yaml_from_goal_type): file
+                for file in files
             }
-            status_str_type_mapping = {}
-            if data:
-                # 在添加到注册表前处理类型替换
-                for device_id, device_config in data.items():
-                    # 添加文件路径信息 - 使用规范化的完整文件路径
-                    if "version" not in device_config:
-                        device_config["version"] = "1.0.0"
-                    if "category" not in device_config:
-                        device_config["category"] = [file.stem]
-                    elif file.stem not in device_config["category"]:
-                        device_config["category"].append(file.stem)
-                    if "config_info" not in device_config:
-                        device_config["config_info"] = []
-                    if "description" not in device_config:
-                        device_config["description"] = ""
-                    if "icon" not in device_config:
-                        device_config["icon"] = ""
-                    if "handles" not in device_config:
-                        device_config["handles"] = []
-                    if "init_param_schema" not in device_config:
-                        device_config["init_param_schema"] = {}
-                    if "class" in device_config:
-                        if (
-                            "status_types" not in device_config["class"]
-                            or device_config["class"]["status_types"] is None
-                        ):
-                            device_config["class"]["status_types"] = {}
-                        if (
-                            "action_value_mappings" not in device_config["class"]
-                            or device_config["class"]["action_value_mappings"] is None
-                        ):
-                            device_config["class"]["action_value_mappings"] = {}
-                        enhanced_info = {}
-                        if complete_registry:
-                            device_config["class"]["status_types"].clear()
-                            enhanced_info = get_enhanced_class_info(device_config["class"]["module"], use_dynamic=True)
-                            if not enhanced_info.get("dynamic_import_success", False):
-                                continue
-                            device_config["class"]["status_types"].update(
-                                {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()}
-                            )
-                        for status_name, status_type in device_config["class"]["status_types"].items():
-                            if isinstance(status_type, tuple) or status_type in ["Any", "None", "Unknown"]:
-                                status_type = "String"  # 替换成ROS的String，便于显示
-                                device_config["class"]["status_types"][status_name] = status_type
-                            try:
-                                target_type = self._replace_type_with_class(
-                                    status_type, device_id, f"状态 {status_name}"
-                                )
-                            except ROSMsgNotFound:
-                                continue
-                            if target_type in [
-                                dict,
-                                list,
-                            ]:  # 对于嵌套类型返回的对象，暂时处理成字符串，无法直接进行转换
-                                target_type = String
-                            status_str_type_mapping[status_type] = target_type
-                        device_config["class"]["status_types"] = dict(
-                            sorted(device_config["class"]["status_types"].items())
-                        )
-                        if complete_registry:
-                            # 保存原有的description信息
-                            old_descriptions = {}
-                            for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                                if "description" in action_config.get("schema", {}):
-                                    description = action_config["schema"]["description"]
-                                    if len(description):
-                                        old_descriptions[action_name] = action_config["schema"]["description"]
+            for future in as_completed(future_to_file):
+                file = future_to_file[future]
+                try:
+                    data, complete_data, is_valid, device_ids = future.result()
+                    if is_valid:
+                        results.append((file, data, device_ids))
+                except Exception as e:
+                    logger.warning(f"[UniLab Registry] 处理设备文件异常: {file}, 错误: {e}")
 
-                            device_config["class"]["action_value_mappings"] = {
-                                k: v
-                                for k, v in device_config["class"]["action_value_mappings"].items()
-                                if not k.startswith("auto-")
-                            }
-                            # 处理动作值映射
-                            device_config["class"]["action_value_mappings"].update(
-                                {
-                                    f"auto-{k}": {
-                                        "type": "UniLabJsonCommandAsync" if v["is_async"] else "UniLabJsonCommand",
-                                        "goal": {},
-                                        "feedback": {},
-                                        "result": {},
-                                        "schema": self._generate_unilab_json_command_schema(
-                                            v["args"], k, v.get("return_annotation")
-                                        ),
-                                        "goal_default": {i["name"]: i["default"] for i in v["args"]},
-                                        "handles": [],
-                                        "placeholder_keys": {
-                                            i["name"]: (
-                                                "unilabos_resources"
-                                                if i["type"] == "unilabos.registry.placeholder_type:ResourceSlot"
-                                                or i["type"]
-                                                == ("list", "unilabos.registry.placeholder_type:ResourceSlot")
-                                                else "unilabos_devices"
-                                            )
-                                            for i in v["args"]
-                                            if i.get("type", "")
-                                            in [
-                                                "unilabos.registry.placeholder_type:ResourceSlot",
-                                                "unilabos.registry.placeholder_type:DeviceSlot",
-                                                ("list", "unilabos.registry.placeholder_type:ResourceSlot"),
-                                                ("list", "unilabos.registry.placeholder_type:DeviceSlot"),
-                                            ]
-                                        },
-                                    }
-                                    # 不生成已配置action的动作
-                                    for k, v in enhanced_info["action_methods"].items()
-                                    if k not in device_config["class"]["action_value_mappings"]
-                                }
-                            )
-                            # 恢复原有的description信息（auto开头的不修改）
-                            for action_name, description in old_descriptions.items():
-                                if action_name in device_config["class"]["action_value_mappings"]:  # 有一些会被删除
-                                    device_config["class"]["action_value_mappings"][action_name]["schema"][
-                                        "description"
-                                    ] = description
-                            device_config["init_param_schema"] = {}
-                            device_config["init_param_schema"]["config"] = self._generate_unilab_json_command_schema(
-                                enhanced_info["init_params"], "__init__"
-                            )["properties"]["goal"]
-                            device_config["init_param_schema"]["data"] = self._generate_status_types_schema(
-                                enhanced_info["status_methods"]
-                            )
-
-                        device_config.pop("schema", None)
-                        device_config["class"]["action_value_mappings"] = dict(
-                            sorted(device_config["class"]["action_value_mappings"].items())
-                        )
-                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                            if "handles" not in action_config:
-                                action_config["handles"] = {}
-                            elif isinstance(action_config["handles"], list):
-                                if len(action_config["handles"]):
-                                    logger.error(f"设备{device_id} {action_name} 的handles配置错误，应该是字典类型")
-                                    continue
-                                else:
-                                    action_config["handles"] = {}
-                            if "type" in action_config:
-                                action_type_str: str = action_config["type"]
-                                # 通过Json发放指令，而不是通过特殊的ros action进行处理
-                                if not action_type_str.startswith("UniLabJsonCommand"):
-                                    try:
-                                        target_type = self._replace_type_with_class(
-                                            action_type_str, device_id, f"动作 {action_name}"
-                                        )
-                                    except ROSMsgNotFound:
-                                        continue
-                                    action_str_type_mapping[action_type_str] = target_type
-                                    if target_type is not None:
-                                        action_config["goal_default"] = yaml.safe_load(
-                                            io.StringIO(get_yaml_from_goal_type(target_type.Goal))
-                                        )
-                                        action_config["schema"] = ros_action_to_json_schema(target_type)
-                                    else:
-                                        logger.warning(
-                                            f"[UniLab Registry] 设备 {device_id} 的动作 {action_name} 类型为空，跳过替换"
-                                        )
-                        complete_data[device_id] = copy.deepcopy(dict(sorted(device_config.items())))  # 稍后dump到文件
-                        for status_name, status_type in device_config["class"]["status_types"].items():
-                            device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
-                        for action_name, action_config in device_config["class"]["action_value_mappings"].items():
-                            if action_config["type"] not in action_str_type_mapping:
-                                continue
-                            action_config["type"] = action_str_type_mapping[action_config["type"]]
-                        # 添加内置的驱动命令动作
-                        self._add_builtin_actions(device_config, device_id)
-                    device_config["file_path"] = str(file.absolute()).replace("\\", "/")
-                    device_config["registry_type"] = "device"
-                    logger.trace(  # type: ignore
-                        f"[UniLab Registry] Device-{current_device_number} File-{i+1}/{len(files)} Add {device_id} "
+        # 线程安全地更新注册表
+        current_device_number = len(self.device_type_registry) + 1
+        with self._registry_lock:
+            for file, data, device_ids in results:
+                self.device_type_registry.update(data)
+                for device_id in device_ids:
+                    logger.trace(
+                        f"[UniLab Registry] Device-{current_device_number} Add {device_id} "
                         + f"[{data[device_id].get('name', '未命名设备')}]"
                     )
                     current_device_number += 1
-                complete_data = dict(sorted(complete_data.items()))
-                complete_data = copy.deepcopy(complete_data)
-                with open(file, "w", encoding="utf-8") as f:
-                    yaml.dump(complete_data, f, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper)
-                self.device_type_registry.update(data)
-            else:
-                logger.debug(
-                    f"[UniLab Registry] Device File-{i+1}/{len(files)} Not Valid YAML File: {file.absolute()}"
-                )
+
+        # 记录无效文件
+        valid_files = {r[0] for r in results}
+        for file in files:
+            if file not in valid_files:
+                logger.debug(f"[UniLab Registry] Device File Not Valid YAML File: {file.absolute()}")
 
     def obtain_registry_device_info(self):
         devices = []

unilabos/registry/resources/bioyond/bottles.yaml

@@ -20,17 +20,6 @@ BIOYOND_PolymerStation_Liquid_Vial:
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-BIOYOND_PolymerStation_Measurement_Vial:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Measurement_Vial
-    type: pylabrobot
-  description: 聚合站-测量小瓶（测密度）
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
 BIOYOND_PolymerStation_Reactor:
   category:
   - bottles

unilabos/resources/bioyond/bottles.py

@@ -193,20 +193,3 @@ def BIOYOND_PolymerStation_Flask(
         barcode=barcode,
         model="BIOYOND_PolymerStation_Flask",
     )
-
-def BIOYOND_PolymerStation_Measurement_Vial(
-    name: str,
-    diameter: float = 25.0,
-    height: float = 60.0,
-    max_volume: float = 20000.0,  # 20mL
-    barcode: str = None,
-) -> Bottle:
-    """创建测量小瓶"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="BIOYOND_PolymerStation_Measurement_Vial",
-    )

unilabos/resources/bioyond/decks.py

@@ -49,17 +49,20 @@ class BIOYOND_PolymerReactionStation_Deck(Deck):
             "测量小瓶仓库(测密度)": bioyond_warehouse_density_vial("测量小瓶仓库(测密度)"),  # A01～B03
         }
         self.warehouse_locations = {
-            "堆栈1左": Coordinate(-200.0, 450.0, 0.0),  # 左侧位置
-            "堆栈1右": Coordinate(2350.0, 450.0, 0.0),  # 右侧位置
-            "站内试剂存放堆栈": Coordinate(730.0, 390.0, 0.0),
+            "堆栈1左": Coordinate(0.0, 430.0, 0.0),  # 左侧位置
+            "堆栈1右": Coordinate(2500.0, 430.0, 0.0),  # 右侧位置
+            "站内试剂存放堆栈": Coordinate(640.0, 480.0, 0.0),
             # "移液站内10%分装液体准备仓库": Coordinate(1200.0, 600.0, 0.0),
             "站内Tip盒堆栈": Coordinate(300.0, 150.0, 0.0),
-            "测量小瓶仓库(测密度)": Coordinate(940.0, 530.0, 0.0),
+            "测量小瓶仓库(测密度)": Coordinate(922.0, 552.0, 0.0),
         }
+        self.warehouses["站内试剂存放堆栈"].rotation = Rotation(z=90)
+        self.warehouses["测量小瓶仓库(测密度)"].rotation = Rotation(z=270)
 
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
+
 class BIOYOND_PolymerPreparationStation_Deck(Deck):
     def __init__(
         self,
@@ -141,7 +144,6 @@ class BIOYOND_YB_Deck(Deck):
 
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
-
 def YB_Deck(name: str) -> Deck:
     by=BIOYOND_YB_Deck(name=name)
     by.setup()

unilabos/resources/bioyond/warehouses.py

@@ -46,55 +46,41 @@ def bioyond_warehouse_1x4x4_right(name: str) -> WareHouse:
     )
 
 def bioyond_warehouse_density_vial(name: str) -> WareHouse:
-    """创建测量小瓶仓库(测密度) - 竖向排列2列3行
-    布局（从下到上，从左到右）：
-    | A03 | B03 |  ← 顶部
-    | A02 | B02 |  ← 中部
-    | A01 | B01 |  ← 底部
-    """
+    """创建测量小瓶仓库(测密度) A01～B03"""
     return warehouse_factory(
         name=name,
-        num_items_x=2,  # 2列（A, B）
-        num_items_y=3,  # 3行（01-03，从下到上）
+        num_items_x=3,  # 3列（01-03）
+        num_items_y=2,  # 2行（A-B）
         num_items_z=1,  # 1层
         dx=10.0,
         dy=10.0,
         dz=10.0,
-        item_dx=40.0,  # 列间距（A到B的横向距离）
-        item_dy=40.0,  # 行间距（01到02到03的竖向距离）
+        item_dx=40.0,
+        item_dy=40.0,
         item_dz=50.0,
-        # ⭐ 竖向warehouse：槽位尺寸也是竖向的（小瓶已经是正方形，无需调整）
+        # 用更小的 resource_size 来表现 "小点的孔位"
         resource_size_x=30.0,
         resource_size_y=30.0,
         resource_size_z=12.0,
         category="warehouse",
         col_offset=0,
-        layout="vertical-col-major",  # ⭐ 竖向warehouse专用布局
+        layout="row-major",
     )
 
 def bioyond_warehouse_reagent_storage(name: str) -> WareHouse:
-    """创建BioYond站内试剂存放堆栈 - 竖向排列1列2行
-    布局（竖向，从下到上）：
-    | A02 |  ← 顶部
-    | A01 |  ← 底部
-    """
+    """创建BioYond站内试剂存放堆栈（A01～A02, 1行×2列）"""
     return warehouse_factory(
         name=name,
-        num_items_x=1,  # 1列
-        num_items_y=2,  # 2行（01-02，从下到上）
+        num_items_x=2,  # 2列（01-02）
+        num_items_y=1,  # 1行（A）
         num_items_z=1,  # 1层
         dx=10.0,
         dy=10.0,
         dz=10.0,
-        item_dx=96.0,   # 列间距（这里只有1列，不重要）
-        item_dy=137.0,  # 行间距（A01到A02的竖向距离）
+        item_dx=137.0,
+        item_dy=96.0,
         item_dz=120.0,
-        # ⭐ 竖向warehouse：交换槽位尺寸，使槽位框也是竖向的
-        resource_size_x=86.0,   # 原来的 resource_size_y
-        resource_size_y=127.0,  # 原来的 resource_size_x
-        resource_size_z=25.0,
         category="warehouse",
-        layout="vertical-col-major",  # ⭐ 竖向warehouse专用布局
     )
 
 def bioyond_warehouse_tipbox_storage(name: str) -> WareHouse:

unilabos/resources/container.py

@@ -27,7 +27,7 @@ class RegularContainer(Container):
 def get_regular_container(name="container"):
     r = RegularContainer(name=name)
     r.category = "container"
-    return RegularContainer(name=name)
+    return r
 
 #
 # class RegularContainer(object):

unilabos/resources/graphio.py

@@ -151,12 +151,40 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
     """
     # 构建 id 到 uuid 的映射
     id_to_uuid: Dict[str, str] = {}
+    uuid_to_id: Dict[str, str] = {}
     for node in resource_tree_set.all_nodes:
         id_to_uuid[node.res_content.id] = node.res_content.uuid
+        uuid_to_id[node.res_content.uuid] = node.res_content.id
+
+    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
+    for link in links:
+        source_id = link.get("source")
+        target_id = link.get("target")
+
+        # 添加 source_uuid
+        if source_id and source_id in id_to_uuid:
+            link["source_uuid"] = id_to_uuid[source_id]
+
+        # 添加 target_uuid
+        if target_id and target_id in id_to_uuid:
+            link["target_uuid"] = id_to_uuid[target_id]
+
+        source_uuid = link.get("source_uuid")
+        target_uuid = link.get("target_uuid")
+
+        # 添加 source_uuid
+        if source_uuid and source_uuid in uuid_to_id:
+            link["source"] = uuid_to_id[source_uuid]
+
+        # 添加 target_uuid
+        if target_uuid and target_uuid in uuid_to_id:
+            link["target"] = uuid_to_id[target_uuid]
 
     # 第一遍处理：将字符串类型的port转换为字典格式
     for link in links:
         port = link.get("port")
+        if port is None:
+            continue
         if link.get("type", "physical") == "physical":
             link["type"] = "fluid"
         if isinstance(port, int):
@@ -179,13 +207,15 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
             link["port"] = {link["source"]: None, link["target"]: None}
 
     # 构建边字典，键为(source节点, target节点)，值为对应的port信息
-    edges = {(link["source"], link["target"]): link["port"] for link in links}
+    edges = {(link["source"], link["target"]): link["port"] for link in links if link.get("port")}
 
     # 第二遍处理：填充反向边的dest信息
     delete_reverses = []
     for i, link in enumerate(links):
         s, t = link["source"], link["target"]
-        current_port = link["port"]
+        current_port = link.get("port")
+        if current_port is None:
+            continue
         if current_port.get(t) is None:
             reverse_key = (t, s)
             reverse_port = edges.get(reverse_key)
@@ -200,20 +230,6 @@ def canonicalize_links_ports(links: List[Dict[str, Any]], resource_tree_set: Res
                 current_port[t] = current_port[s]
     # 删除已被使用反向端口信息的反向边
     standardized_links = [link for i, link in enumerate(links) if i not in delete_reverses]
-
-    # 第三遍处理：为每个 link 添加 source_uuid 和 target_uuid
-    for link in standardized_links:
-        source_id = link.get("source")
-        target_id = link.get("target")
-
-        # 添加 source_uuid
-        if source_id and source_id in id_to_uuid:
-            link["source_uuid"] = id_to_uuid[source_id]
-
-        # 添加 target_uuid
-        if target_id and target_id in id_to_uuid:
-            link["target_uuid"] = id_to_uuid[target_id]
-
     return standardized_links
 
 
@@ -260,7 +276,7 @@ def read_node_link_json(
     resource_tree_set = canonicalize_nodes_data(nodes)
 
     # 标准化边数据
-    links = data.get("links", [])
+    links = data.get("links", data.get("edges", []))
     standardized_links = canonicalize_links_ports(links, resource_tree_set)
 
     # 构建 NetworkX 图（需要转换回 dict 格式）
@@ -284,6 +300,8 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
             edge["sourceHandle"] = port[source]
         elif "source_port" in edge:
             edge["sourceHandle"] = edge.pop("source_port")
+        elif "source_handle" in edge:
+            edge["sourceHandle"] = edge.pop("source_handle")
         else:
             typ = edge.get("type")
             if typ == "communication":
@@ -292,6 +310,8 @@ def modify_to_backend_format(data: list[dict[str, Any]]) -> list[dict[str, Any]]
             edge["targetHandle"] = port[target]
         elif "target_port" in edge:
             edge["targetHandle"] = edge.pop("target_port")
+        elif "target_handle" in edge:
+            edge["targetHandle"] = edge.pop("target_handle")
         else:
             typ = edge.get("type")
             if typ == "communication":
@@ -597,6 +617,8 @@ def resource_plr_to_ulab(resource_plr: "ResourcePLR", parent_name: str = None, w
             "tube": "tube",
             "bottle_carrier": "bottle_carrier",
             "plate_adapter": "plate_adapter",
+            "electrode_sheet": "electrode_sheet",
+            "material_hole": "material_hole",
         }
         if source in replace_info:
             return replace_info[source]
@@ -779,22 +801,6 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
             if not locations:
                 logger.debug(f"[物料位置] {unique_name} 没有location信息，跳过warehouse放置")
 
-            # ⭐ 预先检查：如果物料的任何location在竖向warehouse中，提前交换尺寸
-            # 这样可以避免多个location时尺寸不一致的问题
-            needs_size_swap = False
-            for loc in locations:
-                wh_name_check = loc.get("whName")
-                if wh_name_check in ["站内试剂存放堆栈", "测量小瓶仓库(测密度)"]:
-                    needs_size_swap = True
-                    break
-
-            if needs_size_swap and hasattr(plr_material, 'size_x') and hasattr(plr_material, 'size_y'):
-                original_x = plr_material.size_x
-                original_y = plr_material.size_y
-                plr_material.size_x = original_y
-                plr_material.size_y = original_x
-                logger.debug(f"   物料 {unique_name} 将放入竖向warehouse，预先交换尺寸: {original_x}×{original_y} → {plr_material.size_x}×{plr_material.size_y}")
-
             for loc in locations:
                 wh_name = loc.get("whName")
                 logger.debug(f"[物料位置] {unique_name} 尝试放置到 warehouse: {wh_name} (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')}, z={loc.get('z')})")
@@ -816,6 +822,7 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                     logger.debug(f"[Warehouse匹配] 找到warehouse: {wh_name} (容量: {warehouse.capacity}, 行×列: {warehouse.num_items_x}×{warehouse.num_items_y})")
 
                     # Bioyond坐标映射 (重要！): x→行(1=A,2=B...), y→列(1=01,2=02...), z→层(通常=1)
+                    # PyLabRobot warehouse是列优先存储: A01,B01,C01,D01, A02,B02,C02,D02, ...
                     x = loc.get("x", 1)  # 行号 (1-based: 1=A, 2=B, 3=C, 4=D)
                     y = loc.get("y", 1)  # 列号 (1-based: 1=01, 2=02, 3=03...)
                     z = loc.get("z", 1)  # 层号 (1-based, 通常为1)
@@ -824,23 +831,12 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                     if wh_name == "堆栈1右":
                         y = y - 4  # 将5-8映射到1-4
 
-                    # 特殊处理竖向warehouse（站内试剂存放堆栈、测量小瓶仓库）
-                    # 这些warehouse使用 vertical-col-major 布局
-                    if wh_name in ["站内试剂存放堆栈", "测量小瓶仓库(测密度)"]:
-                        # vertical-col-major 布局的坐标映射：
-                        # - Bioyond的x(1=A,2=B)对应warehouse的列(col, x方向)
-                        # - Bioyond的y(1=01,2=02,3=03)对应warehouse的行(row, y方向)，从下到上
-                        # vertical-col-major 中: row=0 对应底部，row=n-1 对应顶部
-                        # Bioyond y=1(01) 对应底部 → row=0, y=2(02) 对应中间 → row=1
-                        # 索引计算: idx = row * num_cols + col
-                        col_idx = x - 1  # Bioyond的x(A,B) → col索引(0,1)
-                        row_idx = y - 1  # Bioyond的y(01,02,03) → row索引(0,1,2)
-                        layer_idx = z - 1
-
-                        idx = layer_idx * (warehouse.num_items_x * warehouse.num_items_y) + row_idx * warehouse.num_items_x + col_idx
-                        logger.debug(f"🔍 竖向warehouse {wh_name}: Bioyond(x={x},y={y},z={z}) → warehouse(col={col_idx},row={row_idx},layer={layer_idx}) → idx={idx}, capacity={warehouse.capacity}")
-
-                    # 普通横向warehouse的处理
+                    # 特殊处理：对于1行×N列的横向warehouse（如站内试剂存放堆栈）
+                    # Bioyond的y坐标表示线性位置序号，而不是列号
+                    if warehouse.num_items_y == 1:
+                        # 1行warehouse: 直接用y作为线性索引
+                        idx = y - 1
+                        logger.debug(f"1行warehouse {wh_name}: y={y} → idx={idx}")
                     else:
                         # 多行warehouse: 根据 layout 使用不同的索引计算
                         row_idx = x - 1  # x表示行: 转为0-based
@@ -864,7 +860,6 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
 
                     if 0 <= idx < warehouse.capacity:
                         if warehouse[idx] is None or isinstance(warehouse[idx], ResourceHolder):
-                            # 物料尺寸已在放入warehouse前根据需要进行了交换
                             warehouse[idx] = plr_material
                             logger.debug(f"✅ 物料 {unique_name} 放置到 {wh_name}[{idx}] (Bioyond坐标: x={loc.get('x')}, y={loc.get('y')})")
                     else:
@@ -1038,24 +1033,11 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
                 logger.debug(f"  📭 [单瓶物料] {resource.name} 无液体，使用资源名: {material_name}")
 
             # 🎯 处理物料默认参数和单位
-            # 优先级: typeId参数 > 物料名称参数 > 默认值
+            # 检查是否有该物料名称的默认参数配置
             default_unit = "个"  # 默认单位
             material_parameters = {}
 
-            # 1️⃣ 首先检查是否有 typeId 对应的参数配置（从 material_params 中获取，key 格式为 "type:<typeId>"）
-            type_params_key = f"type:{type_id}"
-            if type_params_key in material_params:
-                params_config = material_params[type_params_key].copy()
-
-                # 提取 unit 字段（如果有）
-                if "unit" in params_config:
-                    default_unit = params_config.pop("unit")  # 从参数中移除，放到外层
-
-                # 剩余的字段放入 Parameters
-                material_parameters = params_config
-                logger.debug(f"  🔧 [物料参数-按typeId] 为 typeId={type_id[:8]}... 应用配置: unit={default_unit}, parameters={material_parameters}")
-            # 2️⃣ 其次检查是否有该物料名称的默认参数配置
-            elif material_name in material_params:
+            if material_name in material_params:
                 params_config = material_params[material_name].copy()
 
                 # 提取 unit 字段（如果有）
@@ -1064,7 +1046,7 @@ def resource_plr_to_bioyond(plr_resources: list[ResourcePLR], type_mapping: dict
 
                 # 剩余的字段放入 Parameters
                 material_parameters = params_config
-                logger.debug(f"  🔧 [物料参数-按名称] 为 {material_name} 应用配置: unit={default_unit}, parameters={material_parameters}")
+                logger.debug(f"  🔧 [物料参数] 为 {material_name} 应用配置: unit={default_unit}, parameters={material_parameters}")
 
             # 转换为 JSON 字符串
             parameters_json = json.dumps(material_parameters) if material_parameters else "{}"
@@ -1191,11 +1173,7 @@ def initialize_resource(resource_config: dict, resource_type: Any = None) -> Uni
         if resource_class_config["type"] == "pylabrobot":
             resource_plr = RESOURCE(name=resource_config["name"])
             if resource_type != ResourcePLR:
-                tree_sets = ResourceTreeSet.from_plr_resources([resource_plr])
-                # r = resource_plr_to_ulab(resource_plr=resource_plr, parent_name=resource_config.get("parent", None))
-                # # r = resource_plr_to_ulab(resource_plr=resource_plr)
-                # if resource_config.get("position") is not None:
-                #     r["position"] = resource_config["position"]
+                tree_sets = ResourceTreeSet.from_plr_resources([resource_plr], known_newly_created=True)
                 r = tree_sets.dump()
             else:
                 r = resource_plr

unilabos/resources/itemized_carrier.py

@@ -50,46 +50,13 @@ class Bottle(Well):
         self.barcode = barcode
 
     def serialize(self) -> dict:
-        # Pylabrobot expects barcode to be an object with serialize(), but here it is a str.
-        # We temporarily unset it to avoid AttributeError in super().serialize().
-        _barcode = self.barcode
-        self.barcode = None
-        try:
-            data = super().serialize()
-        finally:
-            self.barcode = _barcode
-
         return {
-            **data,
+            **super().serialize(),
             "diameter": self.diameter,
             "height": self.height,
             "barcode": self.barcode,
         }
 
-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal: bool = False):
-        # Extract barcode before calling parent deserialize to avoid type error
-        barcode_data = data.pop("barcode", None)
-
-        # Call parent deserialize
-        instance = super(Bottle, cls).deserialize(data, allow_marshal=allow_marshal)
-
-        # Set barcode as string (not as Barcode object)
-        if barcode_data:
-            if isinstance(barcode_data, str):
-                instance.barcode = barcode_data
-            elif isinstance(barcode_data, dict):
-                # If it's a dict (Barcode serialized format), extract the data field
-                instance.barcode = barcode_data.get("data", "")
-        else:
-            instance.barcode = ""
-
-        # Set additional attributes
-        instance.diameter = data.get("diameter", instance._size_x)
-        instance.height = data.get("height", instance._size_z)
-
-        return instance
-
 T = TypeVar("T", bound=ResourceHolder)
 
 S = TypeVar("S", bound=ResourceHolder)
@@ -112,6 +79,7 @@ class ItemizedCarrier(ResourcePLR):
     category: Optional[str] = "carrier",
     model: Optional[str] = None,
     invisible_slots: Optional[str] = None,
+    content_type: Optional[List[str]] = ["bottle", "container", "tube", "bottle_carrier", "tip_rack"],
   ):
     super().__init__(
       name=name,
@@ -125,6 +93,7 @@ class ItemizedCarrier(ResourcePLR):
     self.num_items_x, self.num_items_y, self.num_items_z = num_items_x, num_items_y, num_items_z
     self.invisible_slots = [] if invisible_slots is None else invisible_slots
     self.layout = "z-y" if self.num_items_z > 1 and self.num_items_x == 1 else "x-z" if self.num_items_z > 1 and self.num_items_y == 1 else "x-y"
+    self.content_type = content_type
 
     if isinstance(sites, dict):
       sites = sites or {}
@@ -452,7 +421,7 @@ class ItemizedCarrier(ResourcePLR):
                         self[identifier] if isinstance(self[identifier], str) else None,
         "position": {"x": location.x, "y": location.y, "z": location.z},
         "size": self.child_size[identifier],
-        "content_type": ["bottle", "container", "tube", "bottle_carrier", "tip_rack"]
+        "content_type": self.content_type
       } for identifier, location in self.child_locations.items()]
     }
 

unilabos/resources/resource_tracker.py

@@ -1,7 +1,7 @@
 import inspect
 import traceback
 import uuid
-from pydantic import BaseModel, field_serializer, field_validator
+from pydantic import BaseModel, field_serializer, field_validator, ValidationError
 from pydantic import Field
 from typing import List, Tuple, Any, Dict, Literal, Optional, cast, TYPE_CHECKING, Union
 
@@ -13,6 +13,9 @@ if TYPE_CHECKING:
     from pylabrobot.resources import Resource as PLRResource
 
 
+EXTRA_CLASS = "unilabos_resource_class"
+
+
 class ResourceDictPositionSize(BaseModel):
     depth: float = Field(description="Depth", default=0.0)  # z
     width: float = Field(description="Width", default=0.0)  # x
@@ -147,20 +150,24 @@ class ResourceDictInstance(object):
         if not content.get("extra"):  # MagicCode
             content["extra"] = {}
         if "position" in content:
-            pose = content.get("pose",{})
-            if "position" not in pose :
+            pose = content.get("pose", {})
+            if "position" not in pose:
                 if "position" in content["position"]:
                     pose["position"] = content["position"]["position"]
                 else:
                     pose["position"] = {"x": 0, "y": 0, "z": 0}
             if "size" not in pose:
                 pose["size"] = {
-                    "width": content["config"].get("size_x", 0), 
-                    "height": content["config"].get("size_y", 0), 
-                    "depth": content["config"].get("size_z", 0)
+                    "width": content["config"].get("size_x", 0),
+                    "height": content["config"].get("size_y", 0),
+                    "depth": content["config"].get("size_z", 0),
                 }
             content["pose"] = pose
-        return ResourceDictInstance(ResourceDict.model_validate(content))
+        try:
+            res_dict = ResourceDict.model_validate(content)
+            return ResourceDictInstance(res_dict)
+        except ValidationError as err:
+            raise err
 
     def get_plr_nested_dict(self) -> Dict[str, Any]:
         """获取资源实例的嵌套字典表示"""
@@ -322,7 +329,7 @@ class ResourceTreeSet(object):
             )
 
     @classmethod
-    def from_plr_resources(cls, resources: List["PLRResource"]) -> "ResourceTreeSet":
+    def from_plr_resources(cls, resources: List["PLRResource"], known_newly_created=False) -> "ResourceTreeSet":
         """
         从plr资源创建ResourceTreeSet
         """
@@ -339,6 +346,8 @@ class ResourceTreeSet(object):
             }
             if source in replace_info:
                 return replace_info[source]
+            elif source is None:
+                return ""
             else:
                 print("转换pylabrobot的时候，出现未知类型", source)
                 return source
@@ -349,7 +358,8 @@ class ResourceTreeSet(object):
             if not uid:
                 uid = str(uuid.uuid4())
                 res.unilabos_uuid = uid
-                logger.warning(f"{res}没有uuid，请设置后再传入，默认填充{uid}！\n{traceback.format_exc()}")
+                if not known_newly_created:
+                    logger.warning(f"{res}没有uuid，请设置后再传入，默认填充{uid}！\n{traceback.format_exc()}")
 
             # 获取unilabos_extra，默认为空字典
             extra = getattr(res, "unilabos_extra", {})
@@ -386,7 +396,7 @@ class ResourceTreeSet(object):
                 "parent": parent_resource,  # 直接传入 ResourceDict 对象
                 "parent_uuid": parent_uuid,  # 使用 parent_uuid 而不是 parent 对象
                 "type": replace_plr_type(d.get("category", "")),
-                "class": d.get("class", ""),
+                "class": extra.get(EXTRA_CLASS, ""),
                 "position": pos,
                 "pose": pos,
                 "config": {
@@ -436,7 +446,7 @@ class ResourceTreeSet(object):
             trees.append(tree_instance)
         return cls(trees)
 
-    def to_plr_resources(self) -> List["PLRResource"]:
+    def to_plr_resources(self, skip_devices=True) -> List["PLRResource"]:
         """
         将 ResourceTreeSet 转换为 PLR 资源列表
 
@@ -448,13 +458,20 @@ class ResourceTreeSet(object):
         from pylabrobot.utils.object_parsing import find_subclass
 
         # 类型映射
-        TYPE_MAP = {"plate": "Plate", "well": "Well", "deck": "Deck", "container": "RegularContainer", "tip_spot": "TipSpot"}
+        TYPE_MAP = {
+            "plate": "Plate",
+            "well": "Well",
+            "deck": "Deck",
+            "container": "RegularContainer",
+            "tip_spot": "TipSpot",
+        }
 
         def collect_node_data(node: ResourceDictInstance, name_to_uuid: dict, all_states: dict, name_to_extra: dict):
             """一次遍历收集 name_to_uuid, all_states 和 name_to_extra"""
             name_to_uuid[node.res_content.name] = node.res_content.uuid
             all_states[node.res_content.name] = node.res_content.data
             name_to_extra[node.res_content.name] = node.res_content.extra
+            name_to_extra[node.res_content.name][EXTRA_CLASS] = node.res_content.klass
             for child in node.children:
                 collect_node_data(child, name_to_uuid, all_states, name_to_extra)
 
@@ -499,7 +516,10 @@ class ResourceTreeSet(object):
             plr_dict = node_to_plr_dict(tree.root_node, has_model)
             try:
                 sub_cls = find_subclass(plr_dict["type"], PLRResource)
-                if sub_cls is None:
+                if skip_devices and plr_dict["type"] == "device":
+                    logger.info(f"跳过更新 {plr_dict['name']} 设备是class")
+                    continue
+                elif sub_cls is None:
                     raise ValueError(
                         f"无法找到类型 {plr_dict['type']} 对应的 PLR 资源类。原始信息：{tree.root_node.res_content}"
                     )
@@ -507,6 +527,10 @@ class ResourceTreeSet(object):
                 if "category" not in spec.parameters:
                     plr_dict.pop("category", None)
                 plr_resource = sub_cls.deserialize(plr_dict, allow_marshal=True)
+                from pylabrobot.resources import Coordinate
+                from pylabrobot.serializer import deserialize
+                location = cast(Coordinate, deserialize(plr_dict["location"]))
+                plr_resource.location = location
                 plr_resource.load_all_state(all_states)
                 # 使用 DeviceNodeResourceTracker 设置 UUID 和 Extra
                 tracker.loop_set_uuid(plr_resource, name_to_uuid)
@@ -608,16 +632,6 @@ class ResourceTreeSet(object):
         """
         return [tree.root_node for tree in self.trees]
 
-    @property
-    def root_nodes_uuid(self) -> List[ResourceDictInstance]:
-        """
-        获取所有树的根节点
-
-        Returns:
-            所有根节点的资源实例列表
-        """
-        return [tree.root_node.res_content.uuid for tree in self.trees]
-
     @property
     def all_nodes(self) -> List[ResourceDictInstance]:
         """
@@ -928,6 +942,33 @@ class DeviceNodeResourceTracker(object):
 
         return self._traverse_and_process(resource, process)
 
+    def loop_find_with_uuid(self, resource, target_uuid: str):
+        """
+        递归遍历资源树，根据 uuid 查找并返回对应的资源
+
+        Args:
+            resource: 资源对象（可以是list、dict或实例）
+            target_uuid: 要查找的uuid
+
+        Returns:
+            找到的资源对象，未找到则返回None
+        """
+        found_resource = None
+
+        def process(res):
+            nonlocal found_resource
+            if found_resource is not None:
+                return 0  # 已找到，跳过后续处理
+            current_uuid = self._get_resource_attr(res, "uuid", "unilabos_uuid")
+            if current_uuid and current_uuid == target_uuid:
+                found_resource = res
+                logger.trace(f"找到资源UUID: {target_uuid}")
+                return 1
+            return 0
+
+        self._traverse_and_process(resource, process)
+        return found_resource
+
     def loop_set_extra(self, resource, name_to_extra_map: Dict[str, dict]) -> int:
         """
         递归遍历资源树，根据 name 设置所有节点的 extra
@@ -946,7 +987,7 @@ class DeviceNodeResourceTracker(object):
                 extra = name_to_extra_map[resource_name]
                 self.set_resource_extra(res, extra)
                 if len(extra):
-                    logger.debug(f"设置资源Extra: {resource_name} -> {extra}")
+                    logger.trace(f"设置资源Extra: {resource_name} -> {extra}")
                 return 1
             return 0
 
@@ -1113,7 +1154,7 @@ class DeviceNodeResourceTracker(object):
         for key in keys_to_remove:
             self.resource2parent_resource.pop(key, None)
 
-        logger.debug(f"成功移除资源: {resource}")
+        logger.trace(f"[ResourceTracker] 成功移除资源: {resource}")
         return True
 
     def clear_resource(self):

unilabos/resources/warehouse.py

@@ -42,10 +42,6 @@ def warehouse_factory(
                 if layout == "row-major":
                     # 行优先：row=0(A行) 应该显示在上方，需要较小的 y 值
                     y = dy + row * item_dy
-                elif layout == "vertical-col-major":
-                    # 竖向warehouse: row=0 对应顶部（y小），row=n-1 对应底部（y大）
-                    # 但标签 01 应该在底部，所以使用反向映射
-                    y = dy + (num_items_y - row - 1) * item_dy
                 else:
                     # 列优先：保持原逻辑（row=0 对应较大的 y）
                     y = dy + (num_items_y - row - 1) * item_dy
@@ -70,14 +66,6 @@ def warehouse_factory(
         # 行优先顺序: A01,A02,A03,A04, B01,B02,B03,B04
         # locations[0] 对应 row=0, y最大（前端顶部）→ 应该是 A01
         keys = [f"{LETTERS[j]}{i + 1 + col_offset:02d}" for j in range(len_y) for i in range(len_x)]
-    elif layout == "vertical-col-major":
-        # ⭐ 竖向warehouse专用布局：
-        # 字母(A,B,C...)对应列(横向, x方向)，数字(01,02,03...)对应行(竖向, y方向，从下到上)
-        # locations 生成顺序: row→col (row=0,col=0 → row=0,col=1 → row=1,col=0 → ...)
-        # 其中 row=0 对应底部(y大)，row=n-1 对应顶部(y小)
-        # 标签中 01 对应底部(row=0)，02 对应中间(row=1)，03 对应顶部(row=2)
-        # 标签顺序: A01,B01,A02,B02,A03,B03
-        keys = [f"{LETTERS[col]}{row + 1 + col_offset:02d}" for row in range(len_y) for col in range(len_x)]
     else:
         # 列优先顺序: A01,B01,C01,D01, A02,B02,C02,D02
         keys = [f"{LETTERS[j]}{i + 1 + col_offset:02d}" for i in range(len_x) for j in range(len_y)]

unilabos/ros/msgs/message_converter.py

@@ -159,10 +159,14 @@ _msg_converter: Dict[Type, Any] = {
             else Pose()
         ),
         config=json.dumps(x.get("config", {})),
-        data=json.dumps(x.get("data", {})),
+        data=json.dumps(obtain_data_with_uuid(x)),
     ),
 }
 
+def obtain_data_with_uuid(x: dict):
+    data = x.get("data", {})
+    data["unilabos_uuid"] = x.get("uuid", None)
+    return data
 
 def json_or_yaml_loads(data: str) -> Any:
     try:
@@ -357,7 +361,14 @@ def convert_to_ros_msg(ros_msg_type: Union[Type, Any], obj: Any) -> Any:
         if hasattr(ros_msg, key):
             attr = getattr(ros_msg, key)
             if isinstance(attr, (float, int, str, bool)):
-                setattr(ros_msg, key, type(attr)(value))
+                # 处理list类型的值，取第一个元素或抛出错误
+                if isinstance(value, list):
+                    if len(value) > 0:
+                        setattr(ros_msg, key, type(attr)(value[0]))
+                    else:
+                        setattr(ros_msg, key, type(attr)())  # 使用默认值
+                else:
+                    setattr(ros_msg, key, type(attr)(value))
             elif isinstance(attr, (list, tuple)) and isinstance(value, Iterable):
                 td = ros_msg.SLOT_TYPES[ind].value_type
                 if isinstance(td, NamespacedType):
@@ -370,9 +381,35 @@ def convert_to_ros_msg(ros_msg_type: Union[Type, Any], obj: Any) -> Any:
                     setattr(ros_msg, key, [])  # FIXME
             elif "array.array" in str(type(attr)):
                 if attr.typecode == "f" or attr.typecode == "d":
+                    # 如果是单个值，转换为列表
+                    if value is None:
+                        value = []
+                    elif not isinstance(value, Iterable) or isinstance(value, (str, bytes)):
+                        value = [value]
                     setattr(ros_msg, key, [float(i) for i in value])
                 else:
-                    setattr(ros_msg, key, value)
+                    # 对于整数数组，需要确保是序列且每个值在有效范围内
+                    if value is None:
+                        value = []
+                    elif not isinstance(value, Iterable) or isinstance(value, (str, bytes)):
+                        # 如果是单个值，转换为列表
+                        value = [value]
+                    # 确保每个整数值在有效范围内（-2147483648 到 2147483647）
+                    converted_value = []
+                    for i in value:
+                        if i is None:
+                            continue  # 跳过 None 值
+                        if isinstance(i, (int, float)):
+                            int_val = int(i)
+                            # 确保在 int32 范围内
+                            if int_val < -2147483648:
+                                int_val = -2147483648
+                            elif int_val > 2147483647:
+                                int_val = 2147483647
+                            converted_value.append(int_val)
+                        else:
+                            converted_value.append(i)
+                    setattr(ros_msg, key, converted_value)
             else:
                 nested_ros_msg = convert_to_ros_msg(type(attr)(), value)
                 setattr(ros_msg, key, nested_ros_msg)

unilabos/ros/nodes/base_device_node.py

@@ -1,3 +1,4 @@
+from ast import Try
 import inspect
 import io
 import json
@@ -392,9 +393,12 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 parent_resource = self.resource_tracker.figure_resource(
                     {"name": bind_parent_id}
                 )
-            for r in rts.root_nodes:
-                # noinspection PyUnresolvedReferences
-                r.res_content.parent_uuid = parent_resource.unilabos_uuid
+                for r in rts.root_nodes:
+                    # noinspection PyUnresolvedReferences
+                    r.res_content.parent_uuid = parent_resource.unilabos_uuid
+            else:
+                for r in rts.root_nodes:
+                    r.res_content.parent_uuid = self.uuid
 
             if len(LIQUID_INPUT_SLOT) and LIQUID_INPUT_SLOT[0] == -1 and len(rts.root_nodes) == 1 and isinstance(rts.root_nodes[0], RegularContainer):
                 # noinspection PyTypeChecker
@@ -430,11 +434,14 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             })
             tree_response: SerialCommand.Response = await client.call_async(request)
             uuid_maps = json.loads(tree_response.response)
-            self.resource_tracker.loop_update_uuid(input_resources, uuid_maps)
+            plr_instances = rts.to_plr_resources()
+            for plr_instance in plr_instances:
+                self.resource_tracker.loop_update_uuid(plr_instance, uuid_maps)
+            rts: ResourceTreeSet = ResourceTreeSet.from_plr_resources(plr_instances)
             self.lab_logger().info(f"Resource tree added. UUID mapping: {len(uuid_maps)} nodes")
             final_response = {
-                "created_resources": rts.dump(),
-                "liquid_input_resources": [],
+                "created_resource_tree": rts.dump(),
+                "liquid_input_resource_tree": [],
             }
             res.response = json.dumps(final_response)
             # 如果driver自己就有assign的方法，那就使用driver自己的assign方法
@@ -460,7 +467,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 return res
             try:
                 if len(rts.root_nodes) == 1 and parent_resource is not None:
-                    plr_instance = rts.to_plr_resources()[0]
+                    plr_instance = plr_instances[0]
                     if isinstance(plr_instance, Plate):
                         empty_liquid_info_in: List[Tuple[Optional[str], float]] = [(None, 0)] * plr_instance.num_items
                         if len(ADD_LIQUID_TYPE) == 1 and len(LIQUID_VOLUME) == 1 and len(LIQUID_INPUT_SLOT) > 1:
@@ -485,7 +492,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             input_wells = []
                             for r in LIQUID_INPUT_SLOT:
                                 input_wells.append(plr_instance.children[r])
-                        final_response["liquid_input_resources"] = ResourceTreeSet.from_plr_resources(input_wells).dump()
+                        final_response["liquid_input_resource_tree"] = ResourceTreeSet.from_plr_resources(input_wells).dump()
                         res.response = json.dumps(final_response)
                     if issubclass(parent_resource.__class__, Deck) and hasattr(parent_resource, "assign_child_at_slot") and "slot" in other_calling_param:
                         other_calling_param["slot"] = int(other_calling_param["slot"])
@@ -619,7 +626,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
         )  # type: ignore
         raw_nodes = json.loads(response.response)
         tree_set = ResourceTreeSet.from_raw_dict_list(raw_nodes)
-        self.lab_logger().trace(f"获取资源结果: {len(tree_set.trees)} 个资源树 {tree_set.root_nodes}")
+        self.lab_logger().debug(f"获取资源结果: {len(tree_set.trees)} 个资源树")
         return tree_set
 
     async def get_resource_with_dir(self, resource_id: str, with_children: bool = True) -> "ResourcePLR":
@@ -653,61 +660,71 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
     def transfer_to_new_resource(
         self, plr_resource: "ResourcePLR", tree: ResourceTreeInstance, additional_add_params: Dict[str, Any]
-    ):
+    ) -> Optional["ResourcePLR"]:
         parent_uuid = tree.root_node.res_content.parent_uuid
-        if parent_uuid:
-            parent_resource: ResourcePLR = self.resource_tracker.uuid_to_resources.get(parent_uuid)
-            if parent_resource is None:
+        if not parent_uuid:
+            self.lab_logger().warning(
+                f"物料{plr_resource} parent未知，挂载到当前节点下，额外参数：{additional_add_params}"
+            )
+            return None
+        if parent_uuid == self.uuid:
+            self.lab_logger().warning(
+                f"物料{plr_resource}请求挂载到{self.identifier}，额外参数：{additional_add_params}"
+            )
+            return None
+        parent_resource: ResourcePLR = self.resource_tracker.uuid_to_resources.get(parent_uuid)
+        if parent_resource is None:
+            self.lab_logger().warning(
+                f"物料{plr_resource}请求挂载{tree.root_node.res_content.name}的父节点{parent_uuid}不存在"
+            )
+        else:
+            try:
+                # 特殊兼容所有plr的物料的assign方法，和create_resource append_resource后期同步
+                additional_params = {}
+                extra = getattr(plr_resource, "unilabos_extra", {})
+                if len(extra):
+                    self.lab_logger().info(f"发现物料{plr_resource}额外参数: " + str(extra))
+                if "update_resource_site" in extra:
+                    additional_add_params["site"] = extra["update_resource_site"]
+                site = additional_add_params.get("site", None)
+                spec = inspect.signature(parent_resource.assign_child_resource)
+                if "spot" in spec.parameters:
+                    ordering_dict: Dict[str, Any] = getattr(parent_resource, "_ordering")
+                    if ordering_dict:
+                        site = list(ordering_dict.keys()).index(site)
+                    additional_params["spot"] = site
+                old_parent = plr_resource.parent
+                if old_parent is not None:
+                    # plr并不支持同一个deck的加载和卸载
+                    self.lab_logger().warning(f"物料{plr_resource}请求从{old_parent}卸载")
+                    old_parent.unassign_child_resource(plr_resource)
                 self.lab_logger().warning(
-                    f"物料{plr_resource}请求挂载{tree.root_node.res_content.name}的父节点{parent_uuid}不存在"
+                    f"物料{plr_resource}请求挂载到{parent_resource}，额外参数：{additional_params}"
                 )
-            else:
-                try:
-                    # 特殊兼容所有plr的物料的assign方法，和create_resource append_resource后期同步
-                    additional_params = {}
-                    extra = getattr(plr_resource, "unilabos_extra", {})
-                    if len(extra):
-                        self.lab_logger().info(f"发现物料{plr_resource}额外参数: " + str(extra))
-                    if "update_resource_site" in extra:
-                        additional_add_params["site"] = extra["update_resource_site"]
-                    site = additional_add_params.get("site", None)
-                    spec = inspect.signature(parent_resource.assign_child_resource)
-                    if "spot" in spec.parameters:
-                        ordering_dict: Dict[str, Any] = getattr(parent_resource, "_ordering")
-                        if ordering_dict:
-                            site = list(ordering_dict.keys()).index(site)
-                        additional_params["spot"] = site
-                    old_parent = plr_resource.parent
-                    if old_parent is not None:
-                        # plr并不支持同一个deck的加载和卸载
-                        self.lab_logger().warning(f"物料{plr_resource}请求从{old_parent}卸载")
-                        old_parent.unassign_child_resource(plr_resource)
-                    self.lab_logger().warning(
-                        f"物料{plr_resource}请求挂载到{parent_resource}，额外参数：{additional_params}"
-                    )
 
-                    # ⭐ assign 之前，需要从 resources 列表中移除
-                    # 因为资源将不再是顶级资源，而是成为 parent_resource 的子资源
-                    # 如果不移除，figure_resource 会找到两次：一次在 resources，一次在 parent 的 children
-                    resource_id = id(plr_resource)
-                    for i, r in enumerate(self.resource_tracker.resources):
-                        if id(r) == resource_id:
-                            self.resource_tracker.resources.pop(i)
-                            self.lab_logger().debug(
-                                f"从顶级资源列表中移除 {plr_resource.name}（即将成为 {parent_resource.name} 的子资源）"
-                            )
-                            break
+                # ⭐ assign 之前，需要从 resources 列表中移除
+                # 因为资源将不再是顶级资源，而是成为 parent_resource 的子资源
+                # 如果不移除，figure_resource 会找到两次：一次在 resources，一次在 parent 的 children
+                resource_id = id(plr_resource)
+                for i, r in enumerate(self.resource_tracker.resources):
+                    if id(r) == resource_id:
+                        self.resource_tracker.resources.pop(i)
+                        self.lab_logger().debug(
+                            f"从顶级资源列表中移除 {plr_resource.name}（即将成为 {parent_resource.name} 的子资源）"
+                        )
+                        break
 
-                    parent_resource.assign_child_resource(plr_resource, location=None, **additional_params)
+                parent_resource.assign_child_resource(plr_resource, location=None, **additional_params)
 
-                    func = getattr(self.driver_instance, "resource_tree_transfer", None)
-                    if callable(func):
-                        # 分别是 物料的原来父节点，当前物料的状态，物料的新父节点（此时物料已经重新assign了）
-                        func(old_parent, plr_resource, parent_resource)
-                except Exception as e:
-                    self.lab_logger().warning(
-                        f"物料{plr_resource}请求挂载{tree.root_node.res_content.name}的父节点{parent_resource}[{parent_uuid}]失败！\n{traceback.format_exc()}"
-                    )
+                func = getattr(self.driver_instance, "resource_tree_transfer", None)
+                if callable(func):
+                    # 分别是 物料的原来父节点，当前物料的状态，物料的新父节点（此时物料已经重新assign了）
+                    func(old_parent, plr_resource, parent_resource)
+                return parent_resource
+            except Exception as e:
+                self.lab_logger().warning(
+                    f"物料{plr_resource}请求挂载{tree.root_node.res_content.name}的父节点{parent_resource}[{parent_uuid}]失败！\n{traceback.format_exc()}"
+                )
 
     async def s2c_resource_tree(self, req: SerialCommand_Request, res: SerialCommand_Response):
         """
@@ -722,7 +739,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
         def _handle_add(
             plr_resources: List[ResourcePLR], tree_set: ResourceTreeSet, additional_add_params: Dict[str, Any]
-        ) -> Dict[str, Any]:
+        ) -> Tuple[Dict[str, Any], List[ResourcePLR]]:
             """
             处理资源添加操作的内部函数
 
@@ -734,15 +751,20 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             Returns:
                 操作结果字典
             """
+            parents = []  # 放的是被变更的物料 / 被变更的物料父级
             for plr_resource, tree in zip(plr_resources, tree_set.trees):
                 self.resource_tracker.add_resource(plr_resource)
-                self.transfer_to_new_resource(plr_resource, tree, additional_add_params)
+                parent = self.transfer_to_new_resource(plr_resource, tree, additional_add_params)
+                if parent is not None:
+                    parents.append(parent)
+                else:
+                    parents.append(plr_resource)
 
             func = getattr(self.driver_instance, "resource_tree_add", None)
             if callable(func):
                 func(plr_resources)
 
-            return {"success": True, "action": "add"}
+            return {"success": True, "action": "add"}, parents
 
         def _handle_remove(resources_uuid: List[str]) -> Dict[str, Any]:
             """
@@ -777,11 +799,11 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 if plr_resource.parent is not None:
                     plr_resource.parent.unassign_child_resource(plr_resource)
                 self.resource_tracker.remove_resource(plr_resource)
-                self.lab_logger().info(f"移除物料 {plr_resource} 及其子节点")
+                self.lab_logger().info(f"[资源同步] 移除物料 {plr_resource} 及其子节点")
 
             for other_plr_resource in other_plr_resources:
                 self.resource_tracker.remove_resource(other_plr_resource)
-                self.lab_logger().info(f"移除物料 {other_plr_resource} 及其子节点")
+                self.lab_logger().info(f"[资源同步] 移除物料 {other_plr_resource} 及其子节点")
 
             return {
                 "success": True,
@@ -813,11 +835,16 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 original_instance: ResourcePLR = self.resource_tracker.figure_resource(
                     {"uuid": tree.root_node.res_content.uuid}, try_mode=False
                 )
+                original_parent_resource = original_instance.parent
+                original_parent_resource_uuid = getattr(original_parent_resource, "unilabos_uuid", None)
+                target_parent_resource_uuid = tree.root_node.res_content.uuid_parent
+                not_same_parent = original_parent_resource_uuid != target_parent_resource_uuid and original_parent_resource is not None
+                old_name = original_instance.name
+                new_name = plr_resource.name
+                parent_appended = False
 
-                # Update操作中包含改名：需要先remove再add
-                if original_instance.name != plr_resource.name:
-                    old_name = original_instance.name
-                    new_name = plr_resource.name
+                # Update操作中包含改名：需要先remove再add，这里更新父节点即可
+                if not not_same_parent and old_name != new_name:
                     self.lab_logger().info(f"物料改名操作：{old_name} -> {new_name}")
 
                     # 收集所有相关的uuid（包括子节点）
@@ -826,12 +853,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     _handle_add([original_instance], tree_set, additional_add_params)
 
                     self.lab_logger().info(f"物料改名完成：{old_name} -> {new_name}")
+                    original_instances.append(original_parent_resource)
+                    parent_appended = True
 
                 # 常规更新：不涉及改名
-                original_parent_resource = original_instance.parent
-                original_parent_resource_uuid = getattr(original_parent_resource, "unilabos_uuid", None)
-                target_parent_resource_uuid = tree.root_node.res_content.uuid_parent
-
                 self.lab_logger().info(
                     f"物料{original_instance} 原始父节点{original_parent_resource_uuid} "
                     f"目标父节点{target_parent_resource_uuid} 更新"
@@ -842,13 +867,12 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     original_instance.unilabos_extra = getattr(plr_resource, "unilabos_extra")  # type: ignore  # noqa: E501
 
                 # 如果父节点变化，需要重新挂载
-                if (
-                    original_parent_resource_uuid != target_parent_resource_uuid
-                    and original_parent_resource is not None
-                ):
-                    self.transfer_to_new_resource(original_instance, tree, additional_add_params)
+                if not_same_parent:
+                    parent = self.transfer_to_new_resource(original_instance, tree, additional_add_params)
+                    original_instances.append(parent)
+                    parent_appended = True
                 else:
-                    # 判断是否变更了resource_site
+                    # 判断是否变更了resource_site，重新登记
                     target_site = original_instance.unilabos_extra.get("update_resource_site")
                     sites = original_instance.parent.sites if original_instance.parent is not None and hasattr(original_instance.parent, "sites") else None
                     site_names = list(original_instance.parent._ordering.keys()) if original_instance.parent is not None and hasattr(original_instance.parent, "sites") else []
@@ -856,15 +880,22 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         site_index = sites.index(original_instance)
                         site_name = site_names[site_index]
                         if site_name != target_site:
-                            self.transfer_to_new_resource(original_instance, tree, additional_add_params)
+                            parent = self.transfer_to_new_resource(original_instance, tree, additional_add_params)
+                            if parent is not None:
+                                original_instances.append(parent)
+                                parent_appended = True
 
                 # 加载状态
+                original_instance.location = plr_resource.location
+                original_instance.rotation = plr_resource.rotation
+                original_instance.barcode = plr_resource.barcode
                 original_instance.load_all_state(states)
                 child_count = len(original_instance.get_all_children())
                 self.lab_logger().info(
                     f"更新了资源属性 {plr_resource}[{tree.root_node.res_content.uuid}] " f"及其子节点 {child_count} 个"
                 )
-                original_instances.append(original_instance)
+                if not parent_appended:
+                    original_instances.append(original_instance)
 
             # 调用driver的update回调
             func = getattr(self.driver_instance, "resource_tree_update", None)
@@ -881,8 +912,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 action = i.get("action")  # remove, add, update
                 resources_uuid: List[str] = i.get("data")  # 资源数据
                 additional_add_params = i.get("additional_add_params", {})  # 额外参数
-                self.lab_logger().info(
-                    f"[Resource Tree Update] Processing {action} operation, " f"resources count: {len(resources_uuid)}"
+                self.lab_logger().trace(
+                    f"[资源同步] 处理 {action}, " f"resources count: {len(resources_uuid)}"
                 )
                 tree_set = None
                 if action in ["add", "update"]:
@@ -894,8 +925,20 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         if tree_set is None:
                             raise ValueError("tree_set不能为None")
                         plr_resources = tree_set.to_plr_resources()
-                        result = _handle_add(plr_resources, tree_set, additional_add_params)
-                        new_tree_set = ResourceTreeSet.from_plr_resources(plr_resources)
+                        result, parents = _handle_add(plr_resources, tree_set, additional_add_params)
+                        parents: List[Optional["ResourcePLR"]] = [i for i in parents if i is not None]
+                        # de_dupe_parents = list(set(parents))
+                        # Fix unhashable type error for WareHouse
+                        de_dupe_parents = []
+                        _seen_ids = set()
+                        for p in parents:
+                            if id(p) not in _seen_ids:
+                                _seen_ids.add(id(p))
+                                de_dupe_parents.append(p)
+                        new_tree_set = ResourceTreeSet.from_plr_resources(de_dupe_parents)  # 去重
+                        for tree in new_tree_set.trees:
+                            if tree.root_node.res_content.uuid_parent is None and self.node_name != "host_node":
+                                tree.root_node.res_content.parent_uuid = self.uuid
                         r = SerialCommand.Request()
                         r.command = json.dumps(
                             {"data": {"data": new_tree_set.dump()}, "action": "update"})  # 和Update Resource一致
@@ -914,7 +957,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 plr_resources.append(ResourceTreeSet([tree]).to_plr_resources()[0])
                         result, original_instances = _handle_update(plr_resources, tree_set, additional_add_params)
                         if not BasicConfig.no_update_feedback:
-                            new_tree_set = ResourceTreeSet.from_plr_resources(original_instances)
+                            new_tree_set = ResourceTreeSet.from_plr_resources(original_instances)  # 去重
+                            for tree in new_tree_set.trees:
+                                if tree.root_node.res_content.uuid_parent is None and self.node_name != "host_node":
+                                    tree.root_node.res_content.parent_uuid = self.uuid
                             r = SerialCommand.Request()
                             r.command = json.dumps(
                                 {"data": {"data": new_tree_set.dump()}, "action": "update"})  # 和Update Resource一致
@@ -934,15 +980,15 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             # 返回处理结果
             result_json = {"results": results, "total": len(data)}
             res.response = json.dumps(result_json, ensure_ascii=False, cls=TypeEncoder)
-            self.lab_logger().info(f"[Resource Tree Update] Completed processing {len(data)} operations")
+            # self.lab_logger().info(f"[Resource Tree Update] Completed processing {len(data)} operations")
 
         except json.JSONDecodeError as e:
             error_msg = f"Invalid JSON format: {str(e)}"
-            self.lab_logger().error(f"[Resource Tree Update] {error_msg}")
+            self.lab_logger().error(f"[资源同步] {error_msg}")
             res.response = json.dumps({"success": False, "error": error_msg}, ensure_ascii=False)
         except Exception as e:
             error_msg = f"Unexpected error: {str(e)}"
-            self.lab_logger().error(f"[Resource Tree Update] {error_msg}")
+            self.lab_logger().error(f"[资源同步] {error_msg}")
             self.lab_logger().error(traceback.format_exc())
             res.response = json.dumps({"success": False, "error": error_msg}, ensure_ascii=False)
 
@@ -1263,7 +1309,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                 ACTION, action_paramtypes = self.get_real_function(self.driver_instance, action_name)
 
             action_kwargs = convert_from_ros_msg_with_mapping(goal, action_value_mapping["goal"])
-            self.lab_logger().debug(f"任务 {ACTION.__name__} 接收到原始目标: {action_kwargs}")
+            self.lab_logger().debug(f"任务 {ACTION.__name__} 接收到原始目标: {str(action_kwargs)[:1000]}")
+            self.lab_logger().trace(f"任务 {ACTION.__name__} 接收到原始目标: {action_kwargs}")
             error_skip = False
             # 向Host查询物料当前状态，如果是host本身的增加物料的请求，则直接跳过
             if action_name not in ["create_resource_detailed", "create_resource"]:
@@ -1277,15 +1324,49 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             resource_inputs = action_kwargs[k] if is_sequence else [action_kwargs[k]]
 
                             # 批量查询资源
-                            queried_resources = []
-                            for resource_data in resource_inputs:
-                                plr_resource = await self.get_resource_with_dir(
-                                    resource_id=resource_data["id"], with_children=True
-                                )
-                                if "sample_id" in resource_data:
-                                    plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
-                                queried_resources.append(plr_resource)
+                            queried_resources: list = [None] * len(resource_inputs)
+                            uuid_indices: list[tuple[int, str, dict]] = []  # (index, uuid, resource_data)
 
+                            # 第一遍：处理没有uuid的资源，收集有uuid的资源信息
+                            for idx, resource_data in enumerate(resource_inputs):
+                                unilabos_uuid = resource_data.get("data", {}).get("unilabos_uuid")
+                                if unilabos_uuid is None:
+                                    plr_resource = await self.get_resource_with_dir(
+                                        resource_id=resource_data["id"], with_children=True
+                                    )
+                                    if "sample_id" in resource_data:
+                                        plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
+                                    queried_resources[idx] = plr_resource
+                                else:
+                                    uuid_indices.append((idx, unilabos_uuid, resource_data))
+
+                            # 第二遍：批量查询有uuid的资源
+                            if uuid_indices:
+                                uuids = [item[1] for item in uuid_indices]
+                                resource_tree = await self.get_resource(uuids)
+                                plr_resources = resource_tree.to_plr_resources()
+                                for i, (idx, _, resource_data) in enumerate(uuid_indices):
+                                    plr_resource = plr_resources[i]
+                                    if "sample_id" in resource_data:
+                                        plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
+                                    queried_resources[idx] = plr_resource
+
+                            # 第二遍：批量查询有uuid的资源
+                            if uuid_indices:
+                                uuids = [item[1] for item in uuid_indices]
+                                resource_tree = await self.get_resource(uuids)
+                                plr_resources = resource_tree.to_plr_resources()
+                                # 通过uuid查找对应的plr_resource
+                                tracker = self.resource_tracker
+                                for idx, uuid, resource_data in uuid_indices:
+                                    try:
+                                        plr_resource = tracker.loop_find_with_uuid(plr_resources, uuid)
+                                        if "sample_id" in resource_data:
+                                            plr_resource.unilabos_extra["sample_uuid"] = resource_data["sample_id"]
+                                        queried_resources[idx] = plr_resource
+                                    except Exception as e:
+                                        self.lab_logger().error(f"资源查询失败: {e}\n{traceback.format_exc()}")
+                                        continue
                             self.lab_logger().debug(f"资源查询结果: 共 {len(queried_resources)} 个资源")
 
                             # 通过资源跟踪器获取本地实例
@@ -1330,9 +1411,8 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                                 execution_success = True
                             except Exception as _:
                                 execution_error = traceback.format_exc()
-                                error(
-                                    f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}"
-                                )
+                                error(f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}")
+                                trace(f"异步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}")
 
                         future = ROS2DeviceNode.run_async_func(ACTION, trace_error=False, **action_kwargs)
                         future.add_done_callback(_handle_future_exception)
@@ -1352,8 +1432,9 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         except Exception as _:
                             execution_error = traceback.format_exc()
                             error(
-                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}"
-                            )
+                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{str(action_kwargs)[:1000]}")
+                            trace(
+                                f"同步任务 {ACTION.__name__} 报错了\n{traceback.format_exc()}\n原始输入：{action_kwargs}")
 
                     future.add_done_callback(_handle_future_exception)
 
@@ -1420,8 +1501,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             if isinstance(rs, list):
                                 for r in rs:
                                     res = self.resource_tracker.parent_resource(r)  # 获取 resource 对象
+                            elif type(rs).__name__ == "ResourceHolder":
+                                pass
                             else:
-                                res = self.resource_tracker.parent_resource(r)
+                                res = self.resource_tracker.parent_resource(rs)
                             if id(res) not in seen:
                                 seen.add(id(res))
                                 unique_resources.append(res)
@@ -1497,8 +1580,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                     resource_data = function_args[arg_name]
                     if isinstance(resource_data, dict) and "id" in resource_data:
                         try:
-                            converted_resource = self._convert_resource_sync(resource_data)
-                            function_args[arg_name] = converted_resource
+                            function_args[arg_name] = self._convert_resources_sync(resource_data["uuid"])[0]
                         except Exception as e:
                             self.lab_logger().error(
                                 f"转换ResourceSlot参数 {arg_name} 失败: {e}\n{traceback.format_exc()}"
@@ -1512,68 +1594,84 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                         resource_list = function_args[arg_name]
                         if isinstance(resource_list, list):
                             try:
-                                converted_resources = []
-                                for resource_data in resource_list:
-                                    if isinstance(resource_data, dict) and "id" in resource_data:
-                                        converted_resource = self._convert_resource_sync(resource_data)
-                                        converted_resources.append(converted_resource)
-                                function_args[arg_name] = converted_resources
+                                uuids = [r["uuid"] for r in resource_list if isinstance(r, dict) and "id" in r]
+                                function_args[arg_name] = self._convert_resources_sync(*uuids) if uuids else []
                             except Exception as e:
                                 self.lab_logger().error(
                                     f"转换ResourceSlot列表参数 {arg_name} 失败: {e}\n{traceback.format_exc()}"
                                 )
                                 raise JsonCommandInitError(f"ResourceSlot列表参数转换失败: {arg_name}")
-
+            # todo: 默认反报送
             return function(**function_args)
         except KeyError as ex:
             raise JsonCommandInitError(
                 f"执行动作时JSON缺少function_name或function_args: {ex}\n原JSON: {string}\n{traceback.format_exc()}"
             )
 
-    def _convert_resource_sync(self, resource_data: Dict[str, Any]):
-        """同步转换资源数据为实例"""
-        # 创建资源查询请求
-        r = SerialCommand.Request()
-        r.command = json.dumps(
-            {
-                "id": resource_data.get("id", None),
-                "uuid": resource_data.get("uuid", None),
-                "with_children": True,
-            }
-        )
+    def _convert_resources_sync(self, *uuids: str) -> List["ResourcePLR"]:
+        """同步转换资源 UUID 为实例
 
-        # 同步调用资源查询服务
-        future = self._resource_clients["resource_get"].call_async(r)
+        Args:
+            *uuids: 一个或多个资源 UUID
+
+        Returns:
+            单个 UUID 时返回单个资源实例，多个 UUID 时返回资源实例列表
+        """
+        if not uuids:
+            raise ValueError("至少需要提供一个 UUID")
+
+        uuids_list = list(uuids)
+        future = self._resource_clients["c2s_update_resource_tree"].call_async(SerialCommand.Request(
+            command=json.dumps(
+                {
+                    "data": {"data": uuids_list, "with_children": True},
+                    "action": "get",
+                }
+            )
+        ))
 
         # 等待结果（使用while循环，每次sleep 0.05秒，最多等待30秒）
         timeout = 30.0
         elapsed = 0.0
         while not future.done() and elapsed < timeout:
-            time.sleep(0.05)
-            elapsed += 0.05
+            time.sleep(0.02)
+            elapsed += 0.02
 
         if not future.done():
-            raise Exception(f"资源查询超时: {resource_data}")
+            raise Exception(f"资源查询超时: {uuids_list}")
 
         response = future.result()
         if response is None:
-            raise Exception(f"资源查询返回空结果: {resource_data}")
+            raise Exception(f"资源查询返回空结果: {uuids_list}")
 
         raw_data = json.loads(response.response)
 
         # 转换为 PLR 资源
         tree_set = ResourceTreeSet.from_raw_dict_list(raw_data)
-        plr_resource = tree_set.to_plr_resources()[0]
+        if not len(tree_set.trees):
+            raise Exception(f"资源查询返回空树: {raw_data}")
+        plr_resources = tree_set.to_plr_resources()
 
         # 通过资源跟踪器获取本地实例
-        res = self.resource_tracker.figure_resource(plr_resource, try_mode=True)
-        if len(res) == 0:
-            self.lab_logger().warning(f"资源转换未能索引到实例: {resource_data}，返回新建实例")
-            return plr_resource
-        elif len(res) == 1:
-            return res[0]
-        else:
-            raise ValueError(f"资源转换得到多个实例: {res}")
+        figured_resources: List[ResourcePLR] = []
+        for plr_resource, tree in zip(plr_resources, tree_set.trees):
+            res = self.resource_tracker.figure_resource(plr_resource, try_mode=True)
+            if len(res) == 0:
+                self.lab_logger().warning(f"资源转换未能索引到实例: {tree.root_node.res_content}，返回新建实例")
+                figured_resources.append(plr_resource)
+            elif len(res) == 1:
+                figured_resources.append(res[0])
+            else:
+                raise ValueError(f"资源转换得到多个实例: {res}")
+
+        mapped_plr_resources = []
+        for uuid in uuids_list:
+            for plr_resource in figured_resources:
+                r = self.resource_tracker.loop_find_with_uuid(plr_resource, uuid)
+                mapped_plr_resources.append(r)
+                break
+
+        return mapped_plr_resources
 
     async def _execute_driver_command_async(self, string: str):
         try:

unilabos/ros/nodes/presets/host_node.py

@@ -23,6 +23,7 @@ from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialComma
 from unique_identifier_msgs.msg import UUID
 
 from unilabos.registry.registry import lab_registry
+from unilabos.resources.container import RegularContainer
 from unilabos.resources.graphio import initialize_resource
 from unilabos.resources.registry import add_schema
 from unilabos.ros.initialize_device import initialize_device_from_dict
@@ -361,8 +362,7 @@ class HostNode(BaseROS2DeviceNode):
             request.command = ""
             future = sclient.call_async(request)
             # Use timeout for result as well
-            future.result(timeout_sec=5.0)
-            self.lab_logger().debug(f"[Host Node] Re-register completed for {device_namespace}")
+            future.result()
         except Exception as e:
             # Gracefully handle destruction during shutdown
             if "destruction was requested" in str(e) or self._shutting_down:
@@ -586,11 +586,10 @@ class HostNode(BaseROS2DeviceNode):
         )
 
         try:
-            new_li = []
+            assert len(response) == 1, "Create Resource应当只返回一个结果"
             for i in response:
                 res = json.loads(i)
-                new_li.append(res)
-            return {"resources": new_li, "liquid_input_resources": new_li}
+                return res
         except Exception as ex:
             pass
         _n = "\n"
@@ -795,7 +794,9 @@ class HostNode(BaseROS2DeviceNode):
         assign_sample_id(action_kwargs)
         goal_msg = convert_to_ros_msg(action_client._action_type.Goal(), action_kwargs)
 
-        self.lab_logger().info(f"[Host Node] Sending goal for {action_id}: {goal_msg}")
+        # self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {str(goal_msg)[:1000]}")
+        self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {action_kwargs}")
+        self.lab_logger().trace(f"[Host Node] Sending goal for {action_id}: {goal_msg}")
         action_client.wait_for_server()
         goal_uuid_obj = UUID(uuid=list(u.bytes))
 
@@ -1133,11 +1134,11 @@ class HostNode(BaseROS2DeviceNode):
 
         接收序列化的 ResourceTreeSet 数据并进行处理
         """
-        self.lab_logger().info(f"[Host Node-Resource] Resource tree add request received")
         try:
             # 解析请求数据
             data = json.loads(request.command)
             action = data["action"]
+            self.lab_logger().info(f"[Host Node-Resource] Resource tree {action} request received")
             data = data["data"]
             if action == "add":
                 await self._resource_tree_action_add_callback(data, response)
@@ -1161,7 +1162,7 @@ class HostNode(BaseROS2DeviceNode):
         """
         更新节点信息回调
         """
-        # self.lab_logger().info(f"[Host Node] Node info update request received: {request}")
+        self.lab_logger().trace(f"[Host Node] Node info update request received: {request}")
         try:
             from unilabos.app.communication import get_communication_client
             from unilabos.app.web.client import HTTPClient, http_client
@@ -1243,7 +1244,7 @@ class HostNode(BaseROS2DeviceNode):
             data = json.loads(request.command)
             if "uuid" in data and data["uuid"] is not None:
                 http_req = http_client.resource_tree_get([data["uuid"]], data["with_children"])
-            elif "id" in data and data["id"].startswith("/"):
+            elif "id" in data:
                 http_req = http_client.resource_get(data["id"], data["with_children"])
             else:
                 raise ValueError("没有使用正确的物料 id 或 uuid")
@@ -1453,10 +1454,16 @@ class HostNode(BaseROS2DeviceNode):
         }
 
     def test_resource(
-        self, resource: ResourceSlot, resources: List[ResourceSlot], device: DeviceSlot, devices: List[DeviceSlot]
+        self, resource: ResourceSlot = None, resources: List[ResourceSlot] = None, device: DeviceSlot = None, devices: List[DeviceSlot] = None
     ) -> TestResourceReturn:
+        if resources is None:
+            resources = []
+        if devices is None:
+            devices = []
+        if resource is None:
+            resource = RegularContainer("test_resource传入None")
         return {
-            "resources": ResourceTreeSet.from_plr_resources([resource, *resources]).dump(),
+            "resources": ResourceTreeSet.from_plr_resources([resource, *resources], known_newly_created=True).dump(),
             "devices": [device, *devices],
         }
 
@@ -1508,7 +1515,7 @@ class HostNode(BaseROS2DeviceNode):
 
             # 构建服务地址
             srv_address = f"/srv{namespace}/s2c_resource_tree"
-            self.lab_logger().info(f"[Host Node-Resource] Notifying {device_id} for resource tree {action} operation")
+            self.lab_logger().trace(f"[Host Node-Resource] Host -> {device_id} ResourceTree {action} operation started -------")
 
             # 创建服务客户端
             sclient = self.create_client(SerialCommand, srv_address)
@@ -1543,9 +1550,7 @@ class HostNode(BaseROS2DeviceNode):
                 time.sleep(0.05)
 
             response = future.result()
-            self.lab_logger().info(
-                f"[Host Node-Resource] Resource tree {action} notification completed for {device_id}"
-            )
+            self.lab_logger().trace(f"[Host Node-Resource] Host -> {device_id} ResourceTree {action} operation completed -------")
             return True
 
         except Exception as e:

unilabos/ros/nodes/presets/workstation.py

@@ -6,8 +6,6 @@ from typing import List, Dict, Any, Optional, TYPE_CHECKING
 
 import rclpy
 from rosidl_runtime_py import message_to_ordereddict
-from unilabos_msgs.msg import Resource
-from unilabos_msgs.srv import ResourceUpdate
 
 from unilabos.messages import *  # type: ignore  # protocol names
 from rclpy.action import ActionServer, ActionClient
@@ -15,7 +13,6 @@ from rclpy.action.server import ServerGoalHandle
 from unilabos_msgs.srv._serial_command import SerialCommand_Request, SerialCommand_Response
 
 from unilabos.compile import action_protocol_generators
-from unilabos.resources.graphio import nested_dict_to_list
 from unilabos.ros.initialize_device import initialize_device_from_dict
 from unilabos.ros.msgs.message_converter import (
     get_action_type,
@@ -231,15 +228,15 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
                         try:
                             # 统一处理单个或多个资源
                             resource_id = (
-                                protocol_kwargs[k]["id"] if v == "unilabos_msgs/Resource" else protocol_kwargs[k][0]["id"]
+                                protocol_kwargs[k]["id"]
+                                if v == "unilabos_msgs/Resource"
+                                else protocol_kwargs[k][0]["id"]
                             )
                             resource_uuid = protocol_kwargs[k].get("uuid", None)
                             r = SerialCommand_Request()
                             r.command = json.dumps({"id": resource_id, "uuid": resource_uuid, "with_children": True})
                             # 发送请求并等待响应
-                            response: SerialCommand_Response = await self._resource_clients[
-                                "resource_get"
-                            ].call_async(
+                            response: SerialCommand_Response = await self._resource_clients["resource_get"].call_async(
                                 r
                             )  # type: ignore
                             raw_data = json.loads(response.response)
@@ -307,12 +304,52 @@ class ROS2WorkstationNode(BaseROS2DeviceNode):
 
                 # 向Host更新物料当前状态
                 for k, v in goal.get_fields_and_field_types().items():
-                    if v in ["unilabos_msgs/Resource", "sequence<unilabos_msgs/Resource>"]:
-                        r = ResourceUpdate.Request()
-                        r.resources = [
-                            convert_to_ros_msg(Resource, rs) for rs in nested_dict_to_list(protocol_kwargs[k])
-                        ]
-                        response = await self._resource_clients["resource_update"].call_async(r)
+                    if v not in ["unilabos_msgs/Resource", "sequence<unilabos_msgs/Resource>"]:
+                        continue
+                    self.lab_logger().info(f"更新资源状态: {k}")
+                    try:
+                        # 去重：使用 seen 集合获取唯一的资源对象
+                        seen = set()
+                        unique_resources = []
+
+                        # 获取资源数据，统一转换为列表
+                        resource_data = protocol_kwargs[k]
+                        is_sequence = v != "unilabos_msgs/Resource"
+                        if not is_sequence:
+                            resource_list = [resource_data] if isinstance(resource_data, dict) else resource_data
+                        else:
+                            # 处理序列类型，可能是嵌套列表
+                            resource_list = []
+                            if isinstance(resource_data, list):
+                                for item in resource_data:
+                                    if isinstance(item, list):
+                                        resource_list.extend(item)
+                                    else:
+                                        resource_list.append(item)
+                            else:
+                                resource_list = [resource_data]
+
+                        for res_data in resource_list:
+                            if not isinstance(res_data, dict):
+                                continue
+                            res_name = res_data.get("id") or res_data.get("name")
+                            if not res_name:
+                                continue
+
+                            # 使用 resource_tracker 获取本地 PLR 实例
+                            plr = self.resource_tracker.figure_resource({"name": res_name}, try_mode=False)
+                            # 获取父资源
+                            res = self.resource_tracker.parent_resource(plr)
+                            if id(res) not in seen:
+                                seen.add(id(res))
+                                unique_resources.append(res)
+
+                        # 使用新的资源树接口更新
+                        if unique_resources:
+                            await self.update_resource(unique_resources)
+                    except Exception as e:
+                        self.lab_logger().error(f"资源更新失败: {e}")
+                        self.lab_logger().error(traceback.format_exc())
 
                 # 设置成功状态和返回值
                 execution_success = True

unilabos/test/experiments/prcxi_9320_no_res.json

@@ -0,0 +1,836 @@
+{
+  "nodes": [
+    {
+      "id": "PRCXI",
+      "name": "PRCXI",
+      "type": "device",
+      "class": "liquid_handler.prcxi",
+      "parent": "",
+      "pose": {
+        "size": {
+          "width": 550,
+          "height": 400,
+          "depth": 0
+        }
+      },
+      "config": {
+        "axis": "Left",
+        "deck": {
+          "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
+          "_resource_child_name": "PRCXI_Deck"
+        },
+        "host": "10.20.30.184",
+        "port": 9999,
+        "debug": false,
+        "setup": false,
+        "is_9320": true,
+        "timeout": 10,
+        "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
+        "simulator": false,
+        "channel_num": 2
+      },
+      "data": {
+        "reset_ok": true
+      },
+      "schema": {},
+      "description": "",
+      "model": null,
+      "position": {
+        "x": 0,
+        "y": 700,
+        "z": 0
+      }
+    },
+    {
+      "id": "PRCXI_Deck",
+      "name": "PRCXI_Deck",
+
+      "children": [],
+      "parent": "PRCXI",
+      "type": "deck",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Deck",
+        "size_x": 550,
+        "size_y": 400,
+        "size_z": 17,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "deck",
+        "barcode": null
+      },
+      "data": {}
+    },
+    {
+      "id": "T1",
+      "name": "T1",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 5,
+        "y": 301,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T1",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T2",
+      "name": "T2",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 142.5,
+        "y": 301,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T2",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T3",
+      "name": "T3",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 280,
+        "y": 301,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T3",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T4",
+      "name": "T4",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 417.5,
+        "y": 301,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 94,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T4",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T5",
+      "name": "T5",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 5,
+        "y": 205,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T5",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T6",
+      "name": "T6",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 142.5,
+        "y": 205,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T6",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T7",
+      "name": "T7",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 280,
+        "y": 205,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T7",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T8",
+      "name": "T8",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 417.5,
+        "y": 205,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T8",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T9",
+      "name": "T9",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 5,
+        "y": 109,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T9",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T10",
+      "name": "T10",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 142.5,
+        "y": 109,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T10",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T11",
+      "name": "T11",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 280,
+        "y": 109,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T11",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T12",
+      "name": "T12",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 417.5,
+        "y": 109,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T12",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T13",
+      "name": "T13",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 5,
+        "y": 13,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T13",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T14",
+      "name": "T14",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 142.5,
+        "y": 13,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T14",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T15",
+      "name": "T15",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 280,
+        "y": 13,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T15",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T16",
+      "name": "T16",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 417.5,
+        "y": 13,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300PlateAdapterSite",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 28,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        
+        "sites": [
+          {
+            "label": "T16",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "trash",
+      "name": "trash",
+
+      "children": [],
+      "parent": "T16",
+      "type": "trash",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Trash",
+        "size_x": 127.5,
+        "size_y": 86,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "trash",
+        "model": null,
+        "barcode": null,
+        "max_volume": "Infinity",
+        "material_z_thickness": 0,
+        "compute_volume_from_height": null,
+        "compute_height_from_volume": null
+      },
+      "data": {
+        "liquids": [],
+        "pending_liquids": [],
+        "liquid_history": [],
+        "Material": {
+          "uuid": "730067cf07ae43849ddf4034299030e9"
+        }
+      }
+    }
+  ],
+  "edges": []
+}

unilabos/test/experiments/prcxi_9320_slim.json

@@ -0,0 +1,795 @@
+{
+  "nodes": [
+    {
+      "id": "PRCXI",
+      "name": "PRCXI",
+      "type": "device",
+      "class": "liquid_handler.prcxi",
+      "parent": "",
+      "pose": {
+        "size": {
+          "width": 562,
+          "height": 394,
+          "depth": 0
+        }
+      },
+      "config": {
+        "axis": "Left",
+        "deck": {
+          "_resource_type": "unilabos.devices.liquid_handling.prcxi.prcxi:PRCXI9300Deck",
+          "_resource_child_name": "PRCXI_Deck"
+        },
+        "host": "10.20.30.184",
+        "port": 9999,
+        "debug": true,
+        "setup": true,
+        "is_9320": true,
+        "timeout": 10,
+        "matrix_id": "5de524d0-3f95-406c-86dd-f83626ebc7cb",
+        "simulator": true,
+        "channel_num": 2
+      },
+      "data": {
+        "reset_ok": true
+      },
+      "schema": {},
+      "description": "",
+      "model": null,
+      "position": {
+        "x": 0,
+        "y": 240,
+        "z": 0
+      }
+    },
+    {
+      "id": "PRCXI_Deck",
+      "name": "PRCXI_Deck",
+
+      "children": [],
+      "parent": "PRCXI",
+      "type": "deck",
+      "class": "",
+      "position": {
+        "x": 10,
+        "y": 10,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Deck",
+        "size_x": 542,
+        "size_y": 374,
+        "size_z": 0,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "deck",
+        "barcode": null
+      },
+      "data": {}
+    },
+    {
+      "id": "T1",
+      "name": "T1",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 288,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T1",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T2",
+      "name": "T2",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 138,
+        "y": 288,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T2",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T3",
+      "name": "T3",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 276,
+        "y": 288,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T3",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T4",
+      "name": "T4",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 414,
+        "y": 288,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T4",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T5",
+      "name": "T5",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 192,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T5",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T6",
+      "name": "T6",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 138,
+        "y": 192,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T6",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T7",
+      "name": "T7",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 276,
+        "y": 192,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T7",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T8",
+      "name": "T8",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 414,
+        "y": 192,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T8",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T9",
+      "name": "T9",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 96,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T9",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T10",
+      "name": "T10",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 138,
+        "y": 96,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T10",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T11",
+      "name": "T11",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 276,
+        "y": 96,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T11",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T12",
+      "name": "T12",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 414,
+        "y": 96,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T12",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T13",
+      "name": "T13",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T13",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T14",
+      "name": "T14",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 138,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T14",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T15",
+      "name": "T15",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 276,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T15",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    },
+    {
+      "id": "T16",
+      "name": "T16",
+      "children": [],
+      "parent": "PRCXI_Deck",
+      "type": "plate",
+      "class": "",
+      "position": {
+        "x": 414,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "PRCXI9300Container",
+        "size_x": 127,
+        "size_y": 85.5,
+        "size_z": 10,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {},
+        "sites": [
+          {
+            "label": "T16",
+            "visible": true,
+            "position": { "x": 0, "y": 0, "z": 0 },
+            "size": { "width": 128.0, "height": 86, "depth": 0 },
+            "content_type": [
+              "plate",
+              "tip_rack",
+              "plates",
+              "tip_racks",
+              "tube_rack"
+            ]
+          }
+        ]
+      },
+      "data": {}
+    }
+  ],
+  "edges": []
+}

unilabos/test/experiments/reaction_station_bioyond.json

@@ -14,11 +14,7 @@
             ],
             "type": "device",
             "class": "reaction_station.bioyond",
-            "position": {
-                "x": 0,
-                "y": 1100,
-                "z": 0
-            },
+            "position": {"x": 0, "y": 3800, "z": 0},
             "config": {
                 "config": {
                     "api_key": "DE9BDDA0",
@@ -61,10 +57,6 @@
                         "BIOYOND_PolymerStation_TipBox": [
                             "枪头盒",
                             "3a143890-9d51-60ac-6d6f-6edb43c12041"
-                        ],
-                        "BIOYOND_PolymerStation_Measurement_Vial": [
-                            "测量小瓶",
-                            "b1fc79c9-5864-4f05-8052-6ed3abc18a97"
                         ]
                     }
                 },
@@ -74,9 +66,6 @@
                         "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
                     }
                 },
-                "size_x": 2700.0,
-                "size_y": 1080.0,
-                "size_z": 2000.0,
                 "protocol_type": []
             },
             "data": {}
@@ -88,11 +77,7 @@
             "parent": "reaction_station_bioyond",
             "type": "device",
             "class": "reaction_station.reactor",
-            "position": {
-                "x": 1150,
-                "y": 380,
-                "z": 0
-            },
+            "position": {"x": 1150, "y": 380, "z": 0},
             "config": {},
             "data": {}
         },
@@ -103,11 +88,7 @@
             "parent": "reaction_station_bioyond",
             "type": "device",
             "class": "reaction_station.reactor",
-            "position": {
-                "x": 1365,
-                "y": 380,
-                "z": 0
-            },
+            "position": {"x": 1365, "y": 380, "z": 0},
             "config": {},
             "data": {}
         },
@@ -118,11 +99,7 @@
             "parent": "reaction_station_bioyond",
             "type": "device",
             "class": "reaction_station.reactor",
-            "position": {
-                "x": 1580,
-                "y": 380,
-                "z": 0
-            },
+            "position": {"x": 1580, "y": 380, "z": 0},
             "config": {},
             "data": {}
         },
@@ -133,11 +110,7 @@
             "parent": "reaction_station_bioyond",
             "type": "device",
             "class": "reaction_station.reactor",
-            "position": {
-                "x": 1790,
-                "y": 380,
-                "z": 0
-            },
+            "position": {"x": 1790, "y": 380, "z": 0},
             "config": {},
             "data": {}
         },
@@ -148,11 +121,7 @@
             "parent": "reaction_station_bioyond",
             "type": "device",
             "class": "reaction_station.reactor",
-            "position": {
-                "x": 2010,
-                "y": 380,
-                "z": 0
-            },
+            "position": {"x": 2010, "y": 380, "z": 0},
             "config": {},
             "data": {}
         },
@@ -165,7 +134,7 @@
             "class": "BIOYOND_PolymerReactionStation_Deck",
             "position": {
                 "x": 0,
-                "y": 1100,
+                "y": 0,
                 "z": 0
             },
             "config": {

unilabos/utils/environment_check.py

@@ -24,6 +24,7 @@ class EnvironmentChecker:
             "msgcenterpy": "msgcenterpy",
             "opentrons_shared_data": "opentrons_shared_data",
             "typing_extensions": "typing_extensions",
+            "crcmod": "crcmod-plus",
         }
 
         # 特殊安装包（需要特殊处理的包）

unilabos/utils/requirements.txt

@@ -0,0 +1,18 @@
+networkx
+typing_extensions
+websockets
+msgcenterpy>=0.1.5
+opentrons_shared_data
+pint
+fastapi
+jinja2
+requests
+uvicorn
+pyautogui
+opcua
+pyserial
+pandas
+crcmod-plus
+pymodbus
+matplotlib
+pylibftdi

unilabos/workflow/common.py

@@ -1,3 +1,100 @@
+"""
+工作流转换模块 - JSON 到 WorkflowGraph 的转换流程
+
+==================== 输入格式 (JSON) ====================
+
+{
+    "workflow": [
+        {"action": "transfer_liquid", "action_args": {"sources": "cell_lines", "targets": "Liquid_1", "asp_vol": 100.0, "dis_vol": 74.75, ...}},
+        ...
+    ],
+    "reagent": {
+        "cell_lines": {"slot": 4, "well": ["A1", "A3", "A5"], "labware": "DRUG + YOYO-MEDIA"},
+        "Liquid_1": {"slot": 1, "well": ["A4", "A7", "A10"], "labware": "rep 1"},
+        ...
+    }
+}
+
+==================== 转换步骤 ====================
+
+第一步: 按 slot 去重创建 create_resource 节点（创建板子）
+--------------------------------------------------------------------------------
+- 首先创建一个 Group 节点（type="Group", minimized=true），用于包含所有 create_resource 节点
+- 遍历所有 reagent，按 slot 去重，为每个唯一的 slot 创建一个板子
+- 所有 create_resource 节点的 parent_uuid 指向 Group 节点，minimized=true
+- 生成参数:
+    res_id: plate_slot_{slot}
+    device_id: /PRCXI
+    class_name: PRCXI_BioER_96_wellplate
+    parent: /PRCXI/PRCXI_Deck/T{slot}
+    slot_on_deck: "{slot}"
+- 输出端口: labware（用于连接 set_liquid_from_plate）
+- 控制流: create_resource 之间通过 ready 端口串联
+
+示例: slot=1, slot=4 -> 创建 1 个 Group + 2 个 create_resource 节点
+
+第二步: 为每个 reagent 创建 set_liquid_from_plate 节点（设置液体）
+--------------------------------------------------------------------------------
+- 首先创建一个 Group 节点（type="Group", minimized=true），用于包含所有 set_liquid_from_plate 节点
+- 遍历所有 reagent，为每个试剂创建 set_liquid_from_plate 节点
+- 所有 set_liquid_from_plate 节点的 parent_uuid 指向 Group 节点，minimized=true
+- 生成参数:
+    plate: []（通过连接传递，来自 create_resource 的 labware）
+    well_names: ["A1", "A3", "A5"]（来自 reagent 的 well 数组）
+    liquid_names: ["cell_lines", "cell_lines", "cell_lines"]（与 well 数量一致）
+    volumes: [1e5, 1e5, 1e5]（与 well 数量一致，默认体积）
+- 输入连接: create_resource (labware) -> set_liquid_from_plate (input_plate)
+- 输出端口: output_wells（用于连接 transfer_liquid）
+- 控制流: set_liquid_from_plate 连接在所有 create_resource 之后，通过 ready 端口串联
+
+第三步: 解析 workflow，创建 transfer_liquid 等动作节点
+--------------------------------------------------------------------------------
+- 遍历 workflow 数组，为每个动作创建步骤节点
+- 参数重命名: asp_vol -> asp_vols, dis_vol -> dis_vols, asp_flow_rate -> asp_flow_rates, dis_flow_rate -> dis_flow_rates
+- 参数扩展: 根据 targets 的 wells 数量，将单值扩展为数组
+    例: asp_vol=100.0, targets 有 3 个 wells -> asp_vols=[100.0, 100.0, 100.0]
+- 连接处理: 如果 sources/targets 已通过 set_liquid_from_plate 连接，参数值改为 []
+- 输入连接: set_liquid_from_plate (output_wells) -> transfer_liquid (sources_identifier / targets_identifier)
+- 输出端口: sources_out, targets_out（用于连接下一个 transfer_liquid）
+
+==================== 连接关系图 ====================
+
+控制流 (ready 端口串联):
+    create_resource_1 -> create_resource_2 -> ... -> set_liquid_1 -> set_liquid_2 -> ... -> transfer_liquid_1 -> transfer_liquid_2 -> ...
+
+物料流:
+    [create_resource] --labware--> [set_liquid_from_plate] --output_wells--> [transfer_liquid] --sources_out/targets_out--> [下一个 transfer_liquid]
+          (slot=1)                    (cell_lines)           (input_plate)     (sources_identifier)                          (sources_identifier)
+          (slot=4)                    (Liquid_1)                               (targets_identifier)                          (targets_identifier)
+
+==================== 端口映射 ====================
+
+create_resource:
+    输出: labware
+
+set_liquid_from_plate:
+    输入: input_plate
+    输出: output_plate, output_wells
+
+transfer_liquid:
+    输入: sources -> sources_identifier, targets -> targets_identifier
+    输出: sources -> sources_out, targets -> targets_out
+
+==================== 设备名配置 (device_name) ====================
+
+每个节点都有 device_name 字段，指定在哪个设备上执行:
+- create_resource: device_name = "host_node"（固定）
+- set_liquid_from_plate: device_name = "PRCXI"（可配置，见 DEVICE_NAME_DEFAULT）
+- transfer_liquid 等动作: device_name = "PRCXI"（可配置，见 DEVICE_NAME_DEFAULT）
+
+==================== 校验规则 ====================
+
+- 检查 sources/targets 是否在 reagent 中定义
+- 检查 sources 和 targets 的 wells 数量是否匹配
+- 检查参数数组长度是否与 wells 数量一致
+- 如有问题，在 footer 中添加 [WARN: ...] 标记
+"""
+
 import re
 import uuid
 
@@ -8,6 +105,35 @@ from typing import Dict, List, Any, Tuple, Optional
 
 Json = Dict[str, Any]
 
+
+# ==================== 默认配置 ====================
+
+# 设备名配置
+DEVICE_NAME_HOST = "host_node"  # create_resource 固定在 host_node 上执行
+DEVICE_NAME_DEFAULT = "PRCXI"  # transfer_liquid, set_liquid_from_plate 等动作的默认设备名
+
+# 节点类型
+NODE_TYPE_DEFAULT = "ILab"  # 所有节点的默认类型
+
+# create_resource 节点默认参数
+CREATE_RESOURCE_DEFAULTS = {
+    "device_id": "/PRCXI",
+    "parent_template": "/PRCXI/PRCXI_Deck/T{slot}",  # {slot} 会被替换为实际的 slot 值
+    "class_name": "PRCXI_BioER_96_wellplate",
+}
+
+# 默认液体体积 (uL)
+DEFAULT_LIQUID_VOLUME = 1e5
+
+# 参数重命名映射：单数 -> 复数（用于 transfer_liquid 等动作）
+PARAM_RENAME_MAPPING = {
+    "asp_vol": "asp_vols",
+    "dis_vol": "dis_vols",
+    "asp_flow_rate": "asp_flow_rates",
+    "dis_flow_rate": "dis_flow_rates",
+}
+
+
 # ---------------- Graph ----------------
 
 
@@ -228,7 +354,7 @@ def refactor_data(
 
 
 def build_protocol_graph(
-    labware_info: List[Dict[str, Any]],
+    labware_info: Dict[str, Dict[str, Any]],
     protocol_steps: List[Dict[str, Any]],
     workstation_name: str,
     action_resource_mapping: Optional[Dict[str, str]] = None,
@@ -236,112 +362,267 @@ def build_protocol_graph(
     """统一的协议图构建函数，根据设备类型自动选择构建逻辑
 
     Args:
-        labware_info: labware 信息字典
+        labware_info: labware 信息字典，格式为 {name: {slot, well, labware, ...}, ...}
         protocol_steps: 协议步骤列表
         workstation_name: 工作站名称
         action_resource_mapping: action 到 resource_name 的映射字典，可选
     """
     G = WorkflowGraph()
-    resource_last_writer = {}
+    resource_last_writer = {}  # reagent_name -> "node_id:port"
+    slot_to_create_resource = {}  # slot -> create_resource node_id
 
     protocol_steps = refactor_data(protocol_steps, action_resource_mapping)
-    # 有机化学&移液站协议图构建
-    WORKSTATION_ID = workstation_name
 
-    # 为所有labware创建资源节点
-    res_index = 0
+    # ==================== 第一步：按 slot 去重创建 create_resource 节点 ====================
+    # 收集所有唯一的 slot
+    slots_info = {}  # slot -> {labware, res_id}
     for labware_id, item in labware_info.items():
-        # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
-        node_id = str(uuid.uuid4())
+        slot = str(item.get("slot", ""))
+        if slot and slot not in slots_info:
+            res_id = f"plate_slot_{slot}"
+            slots_info[slot] = {
+                "labware": item.get("labware", ""),
+                "res_id": res_id,
+            }
 
-        # 判断节点类型
-        if "Rack" in str(labware_id) or "Tip" in str(labware_id):
-            lab_node_type = "Labware"
-            description = f"Prepare Labware: {labware_id}"
-            liquid_type = []
-            liquid_volume = []
-        elif item.get("type") == "hardware" or "reactor" in str(labware_id).lower():
-            if "reactor" not in str(labware_id).lower():
-                continue
-            lab_node_type = "Sample"
-            description = f"Prepare Reactor: {labware_id}"
-            liquid_type = []
-            liquid_volume = []
-        else:
-            lab_node_type = "Reagent"
-            description = f"Add Reagent to Flask: {labware_id}"
-            liquid_type = [labware_id]
-            liquid_volume = [1e5]
+    # 创建 Group 节点，包含所有 create_resource 节点
+    group_node_id = str(uuid.uuid4())
+    G.add_node(
+        group_node_id,
+        name="Resources Group",
+        type="Group",
+        parent_uuid="",
+        lab_node_type="Device",
+        template_name="",
+        resource_name="",
+        footer="",
+        minimized=True,
+        param=None,
+    )
+
+    # 为每个唯一的 slot 创建 create_resource 节点
+    res_index = 0
+    last_create_resource_id = None
+    for slot, info in slots_info.items():
+        node_id = str(uuid.uuid4())
+        res_id = info["res_id"]
 
         res_index += 1
         G.add_node(
             node_id,
             template_name="create_resource",
             resource_name="host_node",
-            name=f"Res {res_index}",
-            description=description,
-            lab_node_type=lab_node_type,
+            name=f"Plate {res_index}",
+            description=f"Create plate on slot {slot}",
+            lab_node_type="Labware",
             footer="create_resource-host_node",
+            device_name=DEVICE_NAME_HOST,
+            type=NODE_TYPE_DEFAULT,
+            parent_uuid=group_node_id,  # 指向 Group 节点
+            minimized=True,  # 折叠显示
             param={
-                "res_id": labware_id,
-                "device_id": WORKSTATION_ID,
-                "class_name": "container",
-                "parent": WORKSTATION_ID,
+                "res_id": res_id,
+                "device_id": CREATE_RESOURCE_DEFAULTS["device_id"],
+                "class_name": CREATE_RESOURCE_DEFAULTS["class_name"],
+                "parent": CREATE_RESOURCE_DEFAULTS["parent_template"].format(slot=slot),
                 "bind_locations": {"x": 0.0, "y": 0.0, "z": 0.0},
-                "liquid_input_slot": [-1],
-                "liquid_type": liquid_type,
-                "liquid_volume": liquid_volume,
-                "slot_on_deck": "",
+                "slot_on_deck": slot,
             },
         )
-        resource_last_writer[labware_id] = f"{node_id}:labware"
+        slot_to_create_resource[slot] = node_id
 
-    last_control_node_id = None
+        # create_resource 之间通过 ready 串联
+        if last_create_resource_id is not None:
+            G.add_edge(last_create_resource_id, node_id, source_port="ready", target_port="ready")
+        last_create_resource_id = node_id
+
+    # ==================== 第二步：为每个 reagent 创建 set_liquid_from_plate 节点 ====================
+    # 创建 Group 节点，包含所有 set_liquid_from_plate 节点
+    set_liquid_group_id = str(uuid.uuid4())
+    G.add_node(
+        set_liquid_group_id,
+        name="SetLiquid Group",
+        type="Group",
+        parent_uuid="",
+        lab_node_type="Device",
+        template_name="",
+        resource_name="",
+        footer="",
+        minimized=True,
+        param=None,
+    )
+
+    set_liquid_index = 0
+    last_set_liquid_id = last_create_resource_id  # set_liquid_from_plate 连接在 create_resource 之后
+
+    for labware_id, item in labware_info.items():
+        # 跳过 Tip/Rack 类型
+        if "Rack" in str(labware_id) or "Tip" in str(labware_id):
+            continue
+        if item.get("type") == "hardware":
+            continue
+
+        slot = str(item.get("slot", ""))
+        wells = item.get("well", [])
+        if not wells or not slot:
+            continue
+
+        # res_id 不能有空格
+        res_id = str(labware_id).replace(" ", "_")
+        well_count = len(wells)
+
+        node_id = str(uuid.uuid4())
+        set_liquid_index += 1
+
+        G.add_node(
+            node_id,
+            template_name="set_liquid_from_plate",
+            resource_name="liquid_handler.prcxi",
+            name=f"SetLiquid {set_liquid_index}",
+            description=f"Set liquid: {labware_id}",
+            lab_node_type="Reagent",
+            footer="set_liquid_from_plate-liquid_handler.prcxi",
+            device_name=DEVICE_NAME_DEFAULT,
+            type=NODE_TYPE_DEFAULT,
+            parent_uuid=set_liquid_group_id,  # 指向 Group 节点
+            minimized=True,  # 折叠显示
+            param={
+                "plate": [],  # 通过连接传递
+                "well_names": wells,  # 孔位名数组，如 ["A1", "A3", "A5"]
+                "liquid_names": [res_id] * well_count,
+                "volumes": [DEFAULT_LIQUID_VOLUME] * well_count,
+            },
+        )
+
+        # ready 连接：上一个节点 -> set_liquid_from_plate
+        if last_set_liquid_id is not None:
+            G.add_edge(last_set_liquid_id, node_id, source_port="ready", target_port="ready")
+        last_set_liquid_id = node_id
+
+        # 物料流：create_resource 的 labware -> set_liquid_from_plate 的 input_plate
+        create_res_node_id = slot_to_create_resource.get(slot)
+        if create_res_node_id:
+            G.add_edge(create_res_node_id, node_id, source_port="labware", target_port="input_plate")
+
+        # set_liquid_from_plate 的输出 output_wells 用于连接 transfer_liquid
+        resource_last_writer[labware_id] = f"{node_id}:output_wells"
+
+    last_control_node_id = last_set_liquid_id
+
+    # 端口名称映射：JSON 字段名 -> 实际 handle key
+    INPUT_PORT_MAPPING = {
+        "sources": "sources_identifier",
+        "targets": "targets_identifier",
+        "vessel": "vessel",
+        "to_vessel": "to_vessel",
+        "from_vessel": "from_vessel",
+        "reagent": "reagent",
+        "solvent": "solvent",
+        "compound": "compound",
+    }
+
+    OUTPUT_PORT_MAPPING = {
+        "sources": "sources_out",  # 输出端口是 xxx_out
+        "targets": "targets_out",  # 输出端口是 xxx_out
+        "vessel": "vessel_out",
+        "to_vessel": "to_vessel_out",
+        "from_vessel": "from_vessel_out",
+        "filtrate_vessel": "filtrate_out",
+        "reagent": "reagent",
+        "solvent": "solvent",
+        "compound": "compound",
+    }
+
+    # 需要根据 wells 数量扩展的参数列表（复数形式）
+    EXPAND_BY_WELLS_PARAMS = ["asp_vols", "dis_vols", "asp_flow_rates", "dis_flow_rates"]
 
     # 处理协议步骤
     for step in protocol_steps:
         node_id = str(uuid.uuid4())
-        G.add_node(node_id, **step)
+        params = step.get("param", {}).copy()  # 复制一份，避免修改原数据
+        connected_params = set()  # 记录被连接的参数
+        warnings = []  # 收集警告信息
+
+        # 参数重命名：单数 -> 复数
+        for old_name, new_name in PARAM_RENAME_MAPPING.items():
+            if old_name in params:
+                params[new_name] = params.pop(old_name)
+
+        # 处理输入连接
+        for param_key, target_port in INPUT_PORT_MAPPING.items():
+            resource_name = params.get(param_key)
+            if resource_name and resource_name in resource_last_writer:
+                source_node, source_port = resource_last_writer[resource_name].split(":")
+                G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
+                connected_params.add(param_key)
+            elif resource_name and resource_name not in resource_last_writer:
+                # 资源名在 labware_info 中不存在
+                warnings.append(f"{param_key}={resource_name} 未找到")
+
+        # 获取 targets 对应的 wells 数量，用于扩展参数
+        targets_name = params.get("targets")
+        sources_name = params.get("sources")
+        targets_wells_count = 1
+        sources_wells_count = 1
+
+        if targets_name and targets_name in labware_info:
+            target_wells = labware_info[targets_name].get("well", [])
+            targets_wells_count = len(target_wells) if target_wells else 1
+        elif targets_name:
+            warnings.append(f"targets={targets_name} 未在 reagent 中定义")
+
+        if sources_name and sources_name in labware_info:
+            source_wells = labware_info[sources_name].get("well", [])
+            sources_wells_count = len(source_wells) if source_wells else 1
+        elif sources_name:
+            warnings.append(f"sources={sources_name} 未在 reagent 中定义")
+
+        # 检查 sources 和 targets 的 wells 数量是否匹配
+        if targets_wells_count != sources_wells_count and targets_name and sources_name:
+            warnings.append(f"wells 数量不匹配: sources={sources_wells_count}, targets={targets_wells_count}")
+
+        # 使用 targets 的 wells 数量来扩展参数
+        wells_count = targets_wells_count
+
+        # 扩展单值参数为数组（根据 targets 的 wells 数量）
+        for expand_param in EXPAND_BY_WELLS_PARAMS:
+            if expand_param in params:
+                value = params[expand_param]
+                # 如果是单个值，扩展为数组
+                if not isinstance(value, list):
+                    params[expand_param] = [value] * wells_count
+                # 如果已经是数组但长度不对，记录警告
+                elif len(value) != wells_count:
+                    warnings.append(f"{expand_param} 数量({len(value)})与 wells({wells_count})不匹配")
+
+        # 如果 sources/targets 已通过连接传递，将参数值改为空数组
+        for param_key in connected_params:
+            if param_key in params:
+                params[param_key] = []
+
+        # 更新 step 的 param、footer、device_name 和 type
+        step_copy = step.copy()
+        step_copy["param"] = params
+        step_copy["device_name"] = DEVICE_NAME_DEFAULT  # 动作节点使用默认设备名
+        step_copy["type"] = NODE_TYPE_DEFAULT  # 节点类型
+
+        # 如果有警告，修改 footer 添加警告标记（警告放前面）
+        if warnings:
+            original_footer = step.get("footer", "")
+            step_copy["footer"] = f"[WARN: {'; '.join(warnings)}] {original_footer}"
+
+        G.add_node(node_id, **step_copy)
 
         # 控制流
         if last_control_node_id is not None:
             G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
         last_control_node_id = node_id
 
-        # 物料流
-        params = step.get("param", {})
-        input_resources_possible_names = [
-            "vessel",
-            "to_vessel",
-            "from_vessel",
-            "reagent",
-            "solvent",
-            "compound",
-            "sources",
-            "targets",
-        ]
-
-        for target_port in input_resources_possible_names:
-            resource_name = params.get(target_port)
-            if resource_name and resource_name in resource_last_writer:
-                source_node, source_port = resource_last_writer[resource_name].split(":")
-                G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
-
-        output_resources = {
-            "vessel_out": params.get("vessel"),
-            "from_vessel_out": params.get("from_vessel"),
-            "to_vessel_out": params.get("to_vessel"),
-            "filtrate_out": params.get("filtrate_vessel"),
-            "reagent": params.get("reagent"),
-            "solvent": params.get("solvent"),
-            "compound": params.get("compound"),
-            "sources_out": params.get("sources"),
-            "targets_out": params.get("targets"),
-        }
-
-        for source_port, resource_name in output_resources.items():
+        # 处理输出：更新 resource_last_writer
+        for param_key, output_port in OUTPUT_PORT_MAPPING.items():
+            resource_name = step.get("param", {}).get(param_key)  # 使用原始参数值
             if resource_name:
-                resource_last_writer[resource_name] = f"{node_id}:{source_port}"
+                resource_last_writer[resource_name] = f"{node_id}:{output_port}"
 
     return G
 

unilabos/workflow/convert_from_json.py

@@ -1,21 +1,68 @@
 """
 JSON 工作流转换模块
 
-提供从多种 JSON 格式转换为统一工作流格式的功能。
-支持的格式：
-1. workflow/reagent 格式
-2. steps_info/labware_info 格式
+将 workflow/reagent 格式的 JSON 转换为统一工作流格式。
+
+输入格式:
+{
+    "workflow": [
+        {"action": "...", "action_args": {...}},
+        ...
+    ],
+    "reagent": {
+        "reagent_name": {"slot": int, "well": [...], "labware": "..."},
+        ...
+    }
+}
 """
 
 import json
 from os import PathLike
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from unilabos.workflow.common import WorkflowGraph, build_protocol_graph
 from unilabos.registry.registry import lab_registry
 
 
+# ==================== 字段映射配置 ====================
+
+# action 到 resource_name 的映射
+ACTION_RESOURCE_MAPPING: Dict[str, str] = {
+    # 生物实验操作
+    "transfer_liquid": "liquid_handler.prcxi",
+    "transfer": "liquid_handler.prcxi",
+    "incubation": "incubator.prcxi",
+    "move_labware": "labware_mover.prcxi",
+    "oscillation": "shaker.prcxi",
+    # 有机化学操作
+    "HeatChillToTemp": "heatchill.chemputer",
+    "StopHeatChill": "heatchill.chemputer",
+    "StartHeatChill": "heatchill.chemputer",
+    "HeatChill": "heatchill.chemputer",
+    "Dissolve": "stirrer.chemputer",
+    "Transfer": "liquid_handler.chemputer",
+    "Evaporate": "rotavap.chemputer",
+    "Recrystallize": "reactor.chemputer",
+    "Filter": "filter.chemputer",
+    "Dry": "dryer.chemputer",
+    "Add": "liquid_handler.chemputer",
+}
+
+# action_args 字段到 parameters 字段的映射
+# 格式: {"old_key": "new_key"}, 仅映射需要重命名的字段
+ARGS_FIELD_MAPPING: Dict[str, str] = {
+    # 如果需要字段重命名，在这里配置
+    # "old_field_name": "new_field_name",
+}
+
+# 默认工作站名称
+DEFAULT_WORKSTATION = "PRCXI"
+
+
+# ==================== 核心转换函数 ====================
+
+
 def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List[str]]:
     """
     从 registry 获取指定设备和动作的 handles 配置
@@ -39,12 +86,10 @@ def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List
     handles = action_config.get("handles", {})
 
     if isinstance(handles, dict):
-        # 处理 input handles (作为 target)
         for handle in handles.get("input", []):
             handler_key = handle.get("handler_key", "")
             if handler_key:
                 result["source"].append(handler_key)
-        # 处理 output handles (作为 source)
         for handle in handles.get("output", []):
             handler_key = handle.get("handler_key", "")
             if handler_key:
@@ -69,12 +114,9 @@ def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
     for edge in graph.edges:
         left_uuid = edge.get("source")
         right_uuid = edge.get("target")
-        # target_handle_key是target, right的输入节点（入节点）
-        # source_handle_key是source, left的输出节点（出节点）
         right_source_conn_key = edge.get("target_handle_key", "")
         left_target_conn_key = edge.get("source_handle_key", "")
 
-        # 获取源节点和目标节点信息
         left_node = nodes.get(left_uuid, {})
         right_node = nodes.get(right_uuid, {})
 
@@ -83,164 +125,93 @@ def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
         right_res_name = right_node.get("resource_name", "")
         right_template_name = right_node.get("template_name", "")
 
-        # 获取源节点的 output handles
         left_node_handles = get_action_handles(left_res_name, left_template_name)
         target_valid_keys = left_node_handles.get("target", [])
         target_valid_keys.append("ready")
 
-        # 获取目标节点的 input handles
         right_node_handles = get_action_handles(right_res_name, right_template_name)
         source_valid_keys = right_node_handles.get("source", [])
         source_valid_keys.append("ready")
 
-        # 如果节点配置了 output handles，则 source_port 必须有效
+        # 验证目标节点（right）的输入端口
         if not right_source_conn_key:
-            node_name = left_node.get("name", left_uuid[:8])
-            errors.append(f"源节点 '{node_name}' 的 source_handle_key 为空，" f"应设置为: {source_valid_keys}")
+            node_name = right_node.get("name", right_uuid[:8])
+            errors.append(f"目标节点 '{node_name}' 的输入端口 (target_handle_key) 为空，应设置为: {source_valid_keys}")
         elif right_source_conn_key not in source_valid_keys:
-            node_name = left_node.get("name", left_uuid[:8])
+            node_name = right_node.get("name", right_uuid[:8])
             errors.append(
-                f"源节点 '{node_name}' 的 source 端点 '{right_source_conn_key}' 不存在，" f"支持的端点: {source_valid_keys}"
+                f"目标节点 '{node_name}' 的输入端口 '{right_source_conn_key}' 不存在，支持的输入端口: {source_valid_keys}"
             )
 
-        # 如果节点配置了 input handles，则 target_port 必须有效
+        # 验证源节点（left）的输出端口
         if not left_target_conn_key:
-            node_name = right_node.get("name", right_uuid[:8])
-            errors.append(f"目标节点 '{node_name}' 的 target_handle_key 为空，" f"应设置为: {target_valid_keys}")
+            node_name = left_node.get("name", left_uuid[:8])
+            errors.append(f"源节点 '{node_name}' 的输出端口 (source_handle_key) 为空，应设置为: {target_valid_keys}")
         elif left_target_conn_key not in target_valid_keys:
-            node_name = right_node.get("name", right_uuid[:8])
+            node_name = left_node.get("name", left_uuid[:8])
             errors.append(
-                f"目标节点 '{node_name}' 的 target 端点 '{left_target_conn_key}' 不存在，"
-                f"支持的端点: {target_valid_keys}"
+                f"源节点 '{node_name}' 的输出端口 '{left_target_conn_key}' 不存在，支持的输出端口: {target_valid_keys}"
             )
 
     return len(errors) == 0, errors
 
 
-# action 到 resource_name 的映射
-ACTION_RESOURCE_MAPPING: Dict[str, str] = {
-    # 生物实验操作
-    "transfer_liquid": "liquid_handler.prcxi",
-    "transfer": "liquid_handler.prcxi",
-    "incubation": "incubator.prcxi",
-    "move_labware": "labware_mover.prcxi",
-    "oscillation": "shaker.prcxi",
-    # 有机化学操作
-    "HeatChillToTemp": "heatchill.chemputer",
-    "StopHeatChill": "heatchill.chemputer",
-    "StartHeatChill": "heatchill.chemputer",
-    "HeatChill": "heatchill.chemputer",
-    "Dissolve": "stirrer.chemputer",
-    "Transfer": "liquid_handler.chemputer",
-    "Evaporate": "rotavap.chemputer",
-    "Recrystallize": "reactor.chemputer",
-    "Filter": "filter.chemputer",
-    "Dry": "dryer.chemputer",
-    "Add": "liquid_handler.chemputer",
-}
-
-
-def normalize_steps(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def normalize_workflow_steps(workflow: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """
-    将不同格式的步骤数据规范化为统一格式
+    将 workflow 格式的步骤数据规范化
 
-    支持的输入格式：
-    - action + parameters
-    - action + action_args
-    - operation + parameters
+    输入格式:
+        [{"action": "...", "action_args": {...}}, ...]
+
+    输出格式:
+        [{"action": "...", "parameters": {...}, "step_number": int}, ...]
 
     Args:
-        data: 原始步骤数据列表
+        workflow: workflow 数组
 
     Returns:
-        规范化后的步骤列表，格式为 [{"action": str, "parameters": dict, "description": str?, "step_number": int?}, ...]
+        规范化后的步骤列表
     """
     normalized = []
-    for idx, step in enumerate(data):
-        # 获取动作名称（支持 action 或 operation 字段）
-        action = step.get("action") or step.get("operation")
+    for idx, step in enumerate(workflow):
+        action = step.get("action")
         if not action:
             continue
 
-        # 获取参数（支持 parameters 或 action_args 字段）
-        raw_params = step.get("parameters") or step.get("action_args") or {}
-        params = dict(raw_params)
+        # 获取参数: action_args
+        raw_params = step.get("action_args", {})
+        params = {}
 
-        # 规范化 source/target -> sources/targets
-        if "source" in raw_params and "sources" not in raw_params:
-            params["sources"] = raw_params["source"]
-        if "target" in raw_params and "targets" not in raw_params:
-            params["targets"] = raw_params["target"]
+        # 应用字段映射
+        for key, value in raw_params.items():
+            mapped_key = ARGS_FIELD_MAPPING.get(key, key)
+            params[mapped_key] = value
 
-        # 获取描述（支持 description 或 purpose 字段）
-        description = step.get("description") or step.get("purpose")
+        step_dict = {
+            "action": action,
+            "parameters": params,
+            "step_number": idx + 1,
+        }
 
-        # 获取步骤编号（优先使用原始数据中的 step_number，否则使用索引+1）
-        step_number = step.get("step_number", idx + 1)
-
-        step_dict = {"action": action, "parameters": params, "step_number": step_number}
-        if description:
-            step_dict["description"] = description
+        # 保留描述字段
+        if "description" in step:
+            step_dict["description"] = step["description"]
 
         normalized.append(step_dict)
 
     return normalized
 
 
-def normalize_labware(data: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
-    """
-    将不同格式的 labware 数据规范化为统一的字典格式
-
-    支持的输入格式：
-    - reagent_name + material_name + positions
-    - name + labware + slot
-
-    Args:
-        data: 原始 labware 数据列表
-
-    Returns:
-        规范化后的 labware 字典，格式为 {name: {"slot": int, "labware": str, "well": list, "type": str, "role": str, "name": str}, ...}
-    """
-    labware = {}
-    for item in data:
-        # 获取 key 名称（优先使用 reagent_name，其次是 material_name 或 name）
-        reagent_name = item.get("reagent_name")
-        key = reagent_name or item.get("material_name") or item.get("name")
-        if not key:
-            continue
-
-        key = str(key)
-
-        # 处理重复 key，自动添加后缀
-        idx = 1
-        original_key = key
-        while key in labware:
-            idx += 1
-            key = f"{original_key}_{idx}"
-
-        labware[key] = {
-            "slot": item.get("positions") or item.get("slot"),
-            "labware": item.get("material_name") or item.get("labware"),
-            "well": item.get("well", []),
-            "type": item.get("type", "reagent"),
-            "role": item.get("role", ""),
-            "name": key,
-        }
-
-    return labware
-
-
 def convert_from_json(
     data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
+    workstation_name: str = DEFAULT_WORKSTATION,
     validate: bool = True,
 ) -> WorkflowGraph:
     """
     从 JSON 数据或文件转换为 WorkflowGraph
 
-    支持的 JSON 格式：
-    1. {"workflow": [...], "reagent": {...}} - 直接格式
-    2. {"steps_info": [...], "labware_info": [...]} - 需要规范化的格式
+    JSON 格式:
+        {"workflow": [...], "reagent": {...}}
 
     Args:
         data: JSON 文件路径、字典数据、或 JSON 字符串
@@ -251,7 +222,7 @@ def convert_from_json(
         WorkflowGraph: 构建好的工作流图
 
     Raises:
-        ValueError: 不支持的 JSON 格式 或 句柄校验失败
+        ValueError: 不支持的 JSON 格式
         FileNotFoundError: 文件不存在
         json.JSONDecodeError: JSON 解析失败
     """
@@ -262,7 +233,6 @@ def convert_from_json(
             with path.open("r", encoding="utf-8") as fp:
                 json_data = json.load(fp)
         elif isinstance(data, str):
-            # 尝试作为 JSON 字符串解析
             json_data = json.loads(data)
         else:
             raise FileNotFoundError(f"文件不存在: {data}")
@@ -271,30 +241,24 @@ def convert_from_json(
     else:
         raise TypeError(f"不支持的数据类型: {type(data)}")
 
-    # 根据格式解析数据
-    if "workflow" in json_data and "reagent" in json_data:
-        # 格式1: workflow/reagent（已经是规范格式）
-        protocol_steps = json_data["workflow"]
-        labware_info = json_data["reagent"]
-    elif "steps_info" in json_data and "labware_info" in json_data:
-        # 格式2: steps_info/labware_info（需要规范化）
-        protocol_steps = normalize_steps(json_data["steps_info"])
-        labware_info = normalize_labware(json_data["labware_info"])
-    elif "steps" in json_data and "labware" in json_data:
-        # 格式3: steps/labware（另一种常见格式）
-        protocol_steps = normalize_steps(json_data["steps"])
-        if isinstance(json_data["labware"], list):
-            labware_info = normalize_labware(json_data["labware"])
-        else:
-            labware_info = json_data["labware"]
-    else:
+    # 校验格式
+    if "workflow" not in json_data or "reagent" not in json_data:
         raise ValueError(
-            "不支持的 JSON 格式。支持的格式：\n"
-            "1. {'workflow': [...], 'reagent': {...}}\n"
-            "2. {'steps_info': [...], 'labware_info': [...]}\n"
-            "3. {'steps': [...], 'labware': [...]}"
+            "不支持的 JSON 格式。请使用标准格式:\n"
+            '{"workflow": [{"action": "...", "action_args": {...}}, ...], '
+            '"reagent": {"name": {"slot": int, "well": [...], "labware": "..."}, ...}}'
         )
 
+    # 提取数据
+    workflow = json_data["workflow"]
+    reagent = json_data["reagent"]
+
+    # 规范化步骤数据
+    protocol_steps = normalize_workflow_steps(workflow)
+
+    # reagent 已经是字典格式，直接使用
+    labware_info = reagent
+
     # 构建工作流图
     graph = build_protocol_graph(
         labware_info=labware_info,
@@ -317,7 +281,7 @@ def convert_from_json(
 
 def convert_json_to_node_link(
     data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
+    workstation_name: str = DEFAULT_WORKSTATION,
 ) -> Dict[str, Any]:
     """
     将 JSON 数据转换为 node-link 格式的字典
@@ -335,7 +299,7 @@ def convert_json_to_node_link(
 
 def convert_json_to_workflow_list(
     data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
+    workstation_name: str = DEFAULT_WORKSTATION,
 ) -> List[Dict[str, Any]]:
     """
     将 JSON 数据转换为工作流列表格式
@@ -349,8 +313,3 @@ def convert_json_to_workflow_list(
     """
     graph = convert_from_json(data, workstation_name)
     return graph.to_dict()
-
-
-# 为了向后兼容，保留下划线前缀的别名
-_normalize_steps = normalize_steps
-_normalize_labware = normalize_labware

unilabos/workflow/legacy/convert_from_json_legacy.py

@@ -0,0 +1,356 @@
+"""
+JSON 工作流转换模块
+
+提供从多种 JSON 格式转换为统一工作流格式的功能。
+支持的格式：
+1. workflow/reagent 格式
+2. steps_info/labware_info 格式
+"""
+
+import json
+from os import PathLike
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
+
+from unilabos.workflow.common import WorkflowGraph, build_protocol_graph
+from unilabos.registry.registry import lab_registry
+
+
+def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List[str]]:
+    """
+    从 registry 获取指定设备和动作的 handles 配置
+
+    Args:
+        resource_name: 设备资源名称，如 "liquid_handler.prcxi"
+        template_name: 动作模板名称，如 "transfer_liquid"
+
+    Returns:
+        包含 source 和 target handler_keys 的字典:
+        {"source": ["sources_out", "targets_out", ...], "target": ["sources", "targets", ...]}
+    """
+    result = {"source": [], "target": []}
+
+    device_info = lab_registry.device_type_registry.get(resource_name, {})
+    if not device_info:
+        return result
+
+    action_mappings = device_info.get("class", {}).get("action_value_mappings", {})
+    action_config = action_mappings.get(template_name, {})
+    handles = action_config.get("handles", {})
+
+    if isinstance(handles, dict):
+        # 处理 input handles (作为 target)
+        for handle in handles.get("input", []):
+            handler_key = handle.get("handler_key", "")
+            if handler_key:
+                result["source"].append(handler_key)
+        # 处理 output handles (作为 source)
+        for handle in handles.get("output", []):
+            handler_key = handle.get("handler_key", "")
+            if handler_key:
+                result["target"].append(handler_key)
+
+    return result
+
+
+def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
+    """
+    校验工作流图中所有边的句柄配置是否正确
+
+    Args:
+        graph: 工作流图对象
+
+    Returns:
+        (is_valid, errors): 是否有效，错误信息列表
+    """
+    errors = []
+    nodes = graph.nodes
+
+    for edge in graph.edges:
+        left_uuid = edge.get("source")
+        right_uuid = edge.get("target")
+        # target_handle_key是target, right的输入节点（入节点）
+        # source_handle_key是source, left的输出节点（出节点）
+        right_source_conn_key = edge.get("target_handle_key", "")
+        left_target_conn_key = edge.get("source_handle_key", "")
+
+        # 获取源节点和目标节点信息
+        left_node = nodes.get(left_uuid, {})
+        right_node = nodes.get(right_uuid, {})
+
+        left_res_name = left_node.get("resource_name", "")
+        left_template_name = left_node.get("template_name", "")
+        right_res_name = right_node.get("resource_name", "")
+        right_template_name = right_node.get("template_name", "")
+
+        # 获取源节点的 output handles
+        left_node_handles = get_action_handles(left_res_name, left_template_name)
+        target_valid_keys = left_node_handles.get("target", [])
+        target_valid_keys.append("ready")
+
+        # 获取目标节点的 input handles
+        right_node_handles = get_action_handles(right_res_name, right_template_name)
+        source_valid_keys = right_node_handles.get("source", [])
+        source_valid_keys.append("ready")
+
+        # 如果节点配置了 output handles，则 source_port 必须有效
+        if not right_source_conn_key:
+            node_name = left_node.get("name", left_uuid[:8])
+            errors.append(f"源节点 '{node_name}' 的 source_handle_key 为空，" f"应设置为: {source_valid_keys}")
+        elif right_source_conn_key not in source_valid_keys:
+            node_name = left_node.get("name", left_uuid[:8])
+            errors.append(
+                f"源节点 '{node_name}' 的 source 端点 '{right_source_conn_key}' 不存在，" f"支持的端点: {source_valid_keys}"
+            )
+
+        # 如果节点配置了 input handles，则 target_port 必须有效
+        if not left_target_conn_key:
+            node_name = right_node.get("name", right_uuid[:8])
+            errors.append(f"目标节点 '{node_name}' 的 target_handle_key 为空，" f"应设置为: {target_valid_keys}")
+        elif left_target_conn_key not in target_valid_keys:
+            node_name = right_node.get("name", right_uuid[:8])
+            errors.append(
+                f"目标节点 '{node_name}' 的 target 端点 '{left_target_conn_key}' 不存在，"
+                f"支持的端点: {target_valid_keys}"
+            )
+
+    return len(errors) == 0, errors
+
+
+# action 到 resource_name 的映射
+ACTION_RESOURCE_MAPPING: Dict[str, str] = {
+    # 生物实验操作
+    "transfer_liquid": "liquid_handler.prcxi",
+    "transfer": "liquid_handler.prcxi",
+    "incubation": "incubator.prcxi",
+    "move_labware": "labware_mover.prcxi",
+    "oscillation": "shaker.prcxi",
+    # 有机化学操作
+    "HeatChillToTemp": "heatchill.chemputer",
+    "StopHeatChill": "heatchill.chemputer",
+    "StartHeatChill": "heatchill.chemputer",
+    "HeatChill": "heatchill.chemputer",
+    "Dissolve": "stirrer.chemputer",
+    "Transfer": "liquid_handler.chemputer",
+    "Evaporate": "rotavap.chemputer",
+    "Recrystallize": "reactor.chemputer",
+    "Filter": "filter.chemputer",
+    "Dry": "dryer.chemputer",
+    "Add": "liquid_handler.chemputer",
+}
+
+
+def normalize_steps(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    将不同格式的步骤数据规范化为统一格式
+
+    支持的输入格式：
+    - action + parameters
+    - action + action_args
+    - operation + parameters
+
+    Args:
+        data: 原始步骤数据列表
+
+    Returns:
+        规范化后的步骤列表，格式为 [{"action": str, "parameters": dict, "description": str?, "step_number": int?}, ...]
+    """
+    normalized = []
+    for idx, step in enumerate(data):
+        # 获取动作名称（支持 action 或 operation 字段）
+        action = step.get("action") or step.get("operation")
+        if not action:
+            continue
+
+        # 获取参数（支持 parameters 或 action_args 字段）
+        raw_params = step.get("parameters") or step.get("action_args") or {}
+        params = dict(raw_params)
+
+        # 规范化 source/target -> sources/targets
+        if "source" in raw_params and "sources" not in raw_params:
+            params["sources"] = raw_params["source"]
+        if "target" in raw_params and "targets" not in raw_params:
+            params["targets"] = raw_params["target"]
+
+        # 获取描述（支持 description 或 purpose 字段）
+        description = step.get("description") or step.get("purpose")
+
+        # 获取步骤编号（优先使用原始数据中的 step_number，否则使用索引+1）
+        step_number = step.get("step_number", idx + 1)
+
+        step_dict = {"action": action, "parameters": params, "step_number": step_number}
+        if description:
+            step_dict["description"] = description
+
+        normalized.append(step_dict)
+
+    return normalized
+
+
+def normalize_labware(data: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """
+    将不同格式的 labware 数据规范化为统一的字典格式
+
+    支持的输入格式：
+    - reagent_name + material_name + positions
+    - name + labware + slot
+
+    Args:
+        data: 原始 labware 数据列表
+
+    Returns:
+        规范化后的 labware 字典，格式为 {name: {"slot": int, "labware": str, "well": list, "type": str, "role": str, "name": str}, ...}
+    """
+    labware = {}
+    for item in data:
+        # 获取 key 名称（优先使用 reagent_name，其次是 material_name 或 name）
+        reagent_name = item.get("reagent_name")
+        key = reagent_name or item.get("material_name") or item.get("name")
+        if not key:
+            continue
+
+        key = str(key)
+
+        # 处理重复 key，自动添加后缀
+        idx = 1
+        original_key = key
+        while key in labware:
+            idx += 1
+            key = f"{original_key}_{idx}"
+
+        labware[key] = {
+            "slot": item.get("positions") or item.get("slot"),
+            "labware": item.get("material_name") or item.get("labware"),
+            "well": item.get("well", []),
+            "type": item.get("type", "reagent"),
+            "role": item.get("role", ""),
+            "name": key,
+        }
+
+    return labware
+
+
+def convert_from_json(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+    validate: bool = True,
+) -> WorkflowGraph:
+    """
+    从 JSON 数据或文件转换为 WorkflowGraph
+
+    支持的 JSON 格式：
+    1. {"workflow": [...], "reagent": {...}} - 直接格式
+    2. {"steps_info": [...], "labware_info": [...]} - 需要规范化的格式
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+        validate: 是否校验句柄配置，默认 True
+
+    Returns:
+        WorkflowGraph: 构建好的工作流图
+
+    Raises:
+        ValueError: 不支持的 JSON 格式 或 句柄校验失败
+        FileNotFoundError: 文件不存在
+        json.JSONDecodeError: JSON 解析失败
+    """
+    # 处理输入数据
+    if isinstance(data, (str, PathLike)):
+        path = Path(data)
+        if path.exists():
+            with path.open("r", encoding="utf-8") as fp:
+                json_data = json.load(fp)
+        elif isinstance(data, str):
+            # 尝试作为 JSON 字符串解析
+            json_data = json.loads(data)
+        else:
+            raise FileNotFoundError(f"文件不存在: {data}")
+    elif isinstance(data, dict):
+        json_data = data
+    else:
+        raise TypeError(f"不支持的数据类型: {type(data)}")
+
+    # 根据格式解析数据
+    if "workflow" in json_data and "reagent" in json_data:
+        # 格式1: workflow/reagent（已经是规范格式）
+        protocol_steps = json_data["workflow"]
+        labware_info = json_data["reagent"]
+    elif "steps_info" in json_data and "labware_info" in json_data:
+        # 格式2: steps_info/labware_info（需要规范化）
+        protocol_steps = normalize_steps(json_data["steps_info"])
+        labware_info = normalize_labware(json_data["labware_info"])
+    elif "steps" in json_data and "labware" in json_data:
+        # 格式3: steps/labware（另一种常见格式）
+        protocol_steps = normalize_steps(json_data["steps"])
+        if isinstance(json_data["labware"], list):
+            labware_info = normalize_labware(json_data["labware"])
+        else:
+            labware_info = json_data["labware"]
+    else:
+        raise ValueError(
+            "不支持的 JSON 格式。支持的格式：\n"
+            "1. {'workflow': [...], 'reagent': {...}}\n"
+            "2. {'steps_info': [...], 'labware_info': [...]}\n"
+            "3. {'steps': [...], 'labware': [...]}"
+        )
+
+    # 构建工作流图
+    graph = build_protocol_graph(
+        labware_info=labware_info,
+        protocol_steps=protocol_steps,
+        workstation_name=workstation_name,
+        action_resource_mapping=ACTION_RESOURCE_MAPPING,
+    )
+
+    # 校验句柄配置
+    if validate:
+        is_valid, errors = validate_workflow_handles(graph)
+        if not is_valid:
+            import warnings
+
+            for error in errors:
+                warnings.warn(f"句柄校验警告: {error}")
+
+    return graph
+
+
+def convert_json_to_node_link(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+) -> Dict[str, Any]:
+    """
+    将 JSON 数据转换为 node-link 格式的字典
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+
+    Returns:
+        Dict: node-link 格式的工作流数据
+    """
+    graph = convert_from_json(data, workstation_name)
+    return graph.to_node_link_dict()
+
+
+def convert_json_to_workflow_list(
+    data: Union[str, PathLike, Dict[str, Any]],
+    workstation_name: str = "PRCXi",
+) -> List[Dict[str, Any]]:
+    """
+    将 JSON 数据转换为工作流列表格式
+
+    Args:
+        data: JSON 文件路径、字典数据、或 JSON 字符串
+        workstation_name: 工作站名称，默认 "PRCXi"
+
+    Returns:
+        List: 工作流节点列表
+    """
+    graph = convert_from_json(data, workstation_name)
+    return graph.to_dict()
+
+
+# 为了向后兼容，保留下划线前缀的别名
+_normalize_steps = normalize_steps
+_normalize_labware = normalize_labware

unilabos_msgs/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>unilabos_msgs</name>
-  <version>0.10.15</version>
+  <version>0.10.17</version>
   <description>ROS2 Messages package for unilabos devices</description>
   <maintainer email="changjh@pku.edu.cn">Junhan Chang</maintainer>
   <maintainer email="18435084+Xuwznln@users.noreply.github.com">Xuwznln</maintainer>