fix dupe upload registry

(cherry picked from commit 4771ff2347)

.conda/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: 0.10.7
+  version: 0.10.5
 
 source:
   path: ../unilabos
@@ -31,14 +31,11 @@ requirements:
   - python ==3.11.11
   - pip
   - setuptools
-  - zstd
-  - zstandard
   run:
   - conda-forge::python ==3.11.11
   - compilers
   - cmake
   - zstd
-  - zstandard
   - ninja
   - if: unix
     then:

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

@@ -1,376 +0,0 @@
-name: Build Conda-Pack Environment
-
-on:
-  workflow_dispatch:
-    inputs:
-      branch:
-        description: '选择要构建的分支'
-        required: true
-        default: 'dev'
-        type: string
-      platforms:
-        description: '选择构建平台 (逗号分隔): linux-64, osx-64, osx-arm64, win-64'
-        required: false
-        default: 'win-64'
-        type: string
-
-jobs:
-  build-conda-pack:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-latest
-            platform: linux-64
-            env_file: unilabos-linux-64.yaml
-            script_ext: sh
-          - os: macos-13 # Intel
-            platform: osx-64
-            env_file: unilabos-osx-64.yaml
-            script_ext: sh
-          - os: macos-latest # ARM64
-            platform: osx-arm64
-            env_file: unilabos-osx-arm64.yaml
-            script_ext: sh
-          - os: windows-latest
-            platform: win-64
-            env_file: unilabos-win64.yaml
-            script_ext: bat
-
-    runs-on: ${{ matrix.os }}
-
-    defaults:
-      run:
-        # Windows uses cmd for better conda/mamba compatibility, Unix uses bash
-        shell: ${{ matrix.platform == 'win-64' && 'cmd /C CALL {0}' || 'bash -el {0}' }}
-
-    steps:
-      - name: Check if platform should be built
-        id: should_build
-        shell: bash
-        run: |
-          if [[ -z "${{ github.event.inputs.platforms }}" ]]; then
-            echo "should_build=true" >> $GITHUB_OUTPUT
-          elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
-            echo "should_build=true" >> $GITHUB_OUTPUT
-          else
-            echo "should_build=false" >> $GITHUB_OUTPUT
-          fi
-
-      - uses: actions/checkout@v4
-        if: steps.should_build.outputs.should_build == 'true'
-        with:
-          ref: ${{ github.event.inputs.branch }}
-          fetch-depth: 0
-
-      - name: Setup Miniforge (with mamba)
-        if: steps.should_build.outputs.should_build == 'true'
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-          miniforge-version: latest
-          use-mamba: true
-          python-version: '3.11.11'
-          channels: conda-forge,robostack-staging,uni-lab,defaults
-          channel-priority: flexible
-          activate-environment: unilab
-          auto-activate-base: true
-          auto-update-conda: false
-          show-channel-urls: true
-
-      - name: Install conda-pack, unilabos and dependencies (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo Installing unilabos and dependencies to unilab environment...
-          echo Using mamba for faster and more reliable dependency resolution...
-          mamba install 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'
-        shell: bash
-        run: |
-          echo "Installing unilabos and dependencies to unilab environment..."
-          echo "Using mamba for faster and more reliable dependency resolution..."
-          mamba install uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
-
-      - name: Get latest ros-humble-unilabos-msgs version (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        id: msgs_version_win
-        run: |
-          echo Checking installed ros-humble-unilabos-msgs version...
-          conda list ros-humble-unilabos-msgs
-          for /f "tokens=2" %%i in ('conda list ros-humble-unilabos-msgs --json ^| python -c "import sys, json; pkgs=json.load(sys.stdin); print(pkgs[0]['version'] if pkgs else 'not-found')"') do set VERSION=%%i
-          echo installed_version=%VERSION% >> %GITHUB_OUTPUT%
-          echo Installed ros-humble-unilabos-msgs version: %VERSION%
-
-      - name: Get latest ros-humble-unilabos-msgs version (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        id: msgs_version_unix
-        shell: bash
-        run: |
-          echo "Checking installed ros-humble-unilabos-msgs version..."
-          VERSION=$(conda list ros-humble-unilabos-msgs --json | python -c "import sys, json; pkgs=json.load(sys.stdin); print(pkgs[0]['version'] if pkgs else 'not-found')")
-          echo "installed_version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Installed ros-humble-unilabos-msgs version: $VERSION"
-
-      - name: Check for newer ros-humble-unilabos-msgs (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo Checking for available ros-humble-unilabos-msgs versions...
-          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo Search completed
-          echo.
-          echo Updating ros-humble-unilabos-msgs to latest version...
-          mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo Already at latest version
-
-      - name: Check for newer ros-humble-unilabos-msgs (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "Checking for available ros-humble-unilabos-msgs versions..."
-          mamba search ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge || echo "Search completed"
-          echo ""
-          echo "Updating ros-humble-unilabos-msgs to latest version..."
-          mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge -y || echo "Already at latest version"
-
-      - name: Install latest unilabos from source (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo Uninstalling existing unilabos...
-          pip uninstall unilabos -y || echo unilabos not installed via pip
-          echo Installing unilabos from source (branch: ${{ github.event.inputs.branch }})...
-          pip install .
-          echo Verifying installation...
-          pip show unilabos
-
-      - name: Install latest unilabos from source (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "Uninstalling existing unilabos..."
-          pip uninstall unilabos -y || echo "unilabos not installed via pip"
-          echo "Installing unilabos from source (branch: ${{ github.event.inputs.branch }})..."
-          pip install .
-          echo "Verifying installation..."
-          pip show unilabos
-
-      - name: Display environment info (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo === Environment Information ===
-          conda env list
-          echo.
-          echo === Installed Packages ===
-          conda list | findstr /C:"unilabos" /C:"ros-humble-unilabos-msgs" || conda list
-          echo.
-          echo === Python Packages ===
-          pip list | findstr unilabos || pip list
-
-      - name: Display environment info (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "=== Environment Information ==="
-          conda env list
-          echo ""
-          echo "=== Installed Packages ==="
-          conda list | grep -E "(unilabos|ros-humble-unilabos-msgs)" || conda list
-          echo ""
-          echo "=== Python Packages ==="
-          pip list | grep unilabos || pip list
-
-      - name: Verify environment integrity (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo Verifying Python version...
-          python -c "import sys; print(f'Python version: {sys.version}')"
-          echo Verifying unilabos import...
-          python -c "import unilabos; print(f'UniLabOS version: {unilabos.__version__}')" || echo Warning: Could not import unilabos
-          echo Checking critical packages...
-          python -c "import rclpy; print('ROS2 rclpy: OK')"
-          echo Running comprehensive verification script...
-          python scripts\verify_installation.py || echo Warning: Verification script reported issues
-          echo Environment verification complete!
-
-      - name: Verify environment integrity (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "Verifying Python version..."
-          python -c "import sys; print(f'Python version: {sys.version}')"
-          echo "Verifying unilabos import..."
-          python -c "import unilabos; print(f'UniLabOS version: {unilabos.__version__}')" || echo "Warning: Could not import unilabos"
-          echo "Checking critical packages..."
-          python -c "import rclpy; print('ROS2 rclpy: OK')"
-          echo "Running comprehensive verification script..."
-          python scripts/verify_installation.py || echo "Warning: Verification script reported issues"
-          echo "Environment verification complete!"
-
-      - name: Pack conda environment (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo Packing unilab environment with conda-pack...
-          conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
-          echo Pack file created:
-          dir unilab-env-${{ matrix.platform }}.tar.gz
-
-      - name: Pack conda environment (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "Packing unilab environment with conda-pack..."
-          conda pack -n unilab -o unilab-env-${{ matrix.platform }}.tar.gz --ignore-missing-files
-          echo "Pack file created:"
-          ls -lh unilab-env-${{ matrix.platform }}.tar.gz
-
-      - name: Prepare Windows distribution package
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo ==========================================
-          echo Creating distribution package...
-          echo Platform: ${{ matrix.platform }}
-          echo ==========================================
-          mkdir dist-package 2>nul || cd .
-
-          rem Copy packed environment
-          echo Adding: unilab-env-${{ matrix.platform }}.tar.gz
-          copy unilab-env-${{ matrix.platform }}.tar.gz dist-package\
-
-          rem Copy installation script
-          echo Adding: install_unilab.bat
-          copy scripts\install_unilab.bat dist-package\
-
-          rem Copy verification script
-          echo Adding: verify_installation.py
-          copy scripts\verify_installation.py dist-package\
-
-          rem Create README using Python script
-          echo Creating: README.txt
-          python scripts\create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package\README.txt
-
-          echo.
-          echo Distribution package contents:
-          dir /b dist-package
-          echo.
-
-      - name: Prepare Unix/Linux distribution package
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "=========================================="
-          echo "Creating distribution package..."
-          echo "Platform: ${{ matrix.platform }}"
-          echo "=========================================="
-          mkdir -p dist-package
-
-          # Copy packed environment
-          echo "Adding: unilab-env-${{ matrix.platform }}.tar.gz"
-          cp unilab-env-${{ matrix.platform }}.tar.gz dist-package/
-
-          # Copy installation script
-          echo "Adding: install_unilab.sh"
-          cp scripts/install_unilab.sh dist-package/
-          chmod +x dist-package/install_unilab.sh
-
-          # Copy verification script
-          echo "Adding: verify_installation.py"
-          cp scripts/verify_installation.py dist-package/
-
-          # Create README using Python script
-          echo "Creating: README.txt"
-          python scripts/create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package/README.txt
-
-          echo ""
-          echo "Distribution package contents:"
-          ls -lh dist-package/
-          echo ""
-
-      - name: Finalize Windows distribution package
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo ==========================================
-          echo Windows distribution package ready
-          echo.
-          echo Package will be uploaded as artifact
-          echo GitHub Actions will automatically create ZIP
-          echo.
-          echo Contents:
-          dir /b dist-package
-          echo.
-          echo Users will download a ZIP containing:
-          echo   - install_unilab.bat
-          echo   - unilab-env-${{ matrix.platform }}.tar.gz
-          echo   - verify_installation.py
-          echo   - README.txt
-          echo ==========================================
-
-      - name: Create Unix/Linux TAR.GZ archive
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "=========================================="
-          echo "Creating Unix/Linux TAR.GZ archive..."
-          echo "Archive: unilab-pack-${{ matrix.platform }}.tar.gz"
-          echo "Contents: install_unilab.sh + unilab-env-${{ matrix.platform }}.tar.gz + extras"
-          tar -czf unilab-pack-${{ matrix.platform }}.tar.gz -C dist-package .
-          echo "=========================================="
-
-          echo ""
-          echo "Final package created:"
-          ls -lh unilab-pack-*
-          echo ""
-          echo "Users can now:"
-          echo "  1. Download unilab-pack-${{ matrix.platform }}.tar.gz"
-          echo "  2. Extract it: tar -xzf unilab-pack-${{ matrix.platform }}.tar.gz"
-          echo "  3. Run: bash install_unilab.sh"
-          echo ""
-
-      - name: Upload distribution package
-        if: steps.should_build.outputs.should_build == 'true'
-        uses: actions/upload-artifact@v4
-        with:
-          name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
-          path: dist-package/
-          retention-days: 90
-          if-no-files-found: error
-
-      - name: Display package info (Windows)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
-        run: |
-          echo ==========================================
-          echo Build Summary
-          echo ==========================================
-          echo Platform: ${{ matrix.platform }}
-          echo Branch: ${{ github.event.inputs.branch }}
-          echo Python version: 3.11.11
-          echo.
-          echo Distribution package contents:
-          dir dist-package
-          echo.
-          echo Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}
-          echo.
-          echo After download, extract the ZIP and run:
-          echo   install_unilab.bat
-          echo ==========================================
-
-      - name: Display package info (Unix)
-        if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
-        shell: bash
-        run: |
-          echo "=========================================="
-          echo "Build Summary"
-          echo "=========================================="
-          echo "Platform: ${{ matrix.platform }}"
-          echo "Branch: ${{ github.event.inputs.branch }}"
-          echo "Python version: 3.11.11"
-          echo ""
-          echo "Distribution package contents:"
-          ls -lh dist-package/
-          echo ""
-          echo "Package size (tar.gz):"
-          ls -lh unilab-pack-*.tar.gz
-          echo ""
-          echo "Artifact name: unilab-pack-${{ matrix.platform }}-${{ github.event.inputs.branch }}"
-          echo ""
-          echo "After download:"
-          echo "  - Windows/macOS: Extract ZIP, then: tar -xzf unilab-pack-${{ matrix.platform }}.tar.gz"
-          echo "  - Linux: Extract ZIP (or download tar.gz directly), run install_unilab.sh"
-          echo "=========================================="

.github/workflows/deploy-docs.yml

@@ -1,98 +0,0 @@
-name: Deploy Docs
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-  workflow_dispatch:
-    inputs:
-      branch:
-        description: '要部署文档的分支'
-        required: false
-        default: 'main'
-        type: string
-      deploy_to_pages:
-        description: '是否部署到 GitHub Pages'
-        required: false
-        default: true
-        type: boolean
-
-# 设置 GITHUB_TOKEN 权限以部署到 GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# 只允许一个并发部署，跳过正在进行和最新排队之间的运行
-# 但是不取消正在进行的运行，因为我们希望允许这些生产部署完成
-concurrency:
-  group: 'pages'
-  cancel-in-progress: false
-
-jobs:
-  # Build documentation
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.inputs.branch || github.ref }}
-
-      - name: Setup Python environment
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y pandoc
-
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          # Install package in development mode to get version info
-          pip install -e .
-          # Install documentation dependencies
-          pip install -r docs/requirements.txt
-
-      - 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')
-
-      - name: Build Sphinx documentation
-        run: |
-          cd docs
-          # Clean previous builds
-          rm -rf _build
-          # Build HTML documentation
-          python -m sphinx -b html . _build/html -v
-
-      - name: Check build results
-        run: |
-          echo "Documentation build completed, checking output directory:"
-          ls -la docs/_build/html/
-          echo "Checking for index.html:"
-          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')
-        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')
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.gitignore

@@ -2,7 +2,6 @@ configs/
 temp/
 output/
 unilabos_data/
-pyrightconfig.json
 ## Python
 
 # Byte-compiled / optimized / DLL files
@@ -247,5 +246,3 @@ local_test2.py
 ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
 *.bz2
 test_config.py
-
-

CONTRIBUTORS

@@ -1,15 +0,0 @@
-   156	Xuwznln <18435084+Xuwznln@users.noreply.github.com>
-    39	Junhan Chang <changjh@dp.tech>
-     9	wznln <18435084+Xuwznln@users.noreply.github.com>
-     8	Guangxin Zhang <guangxin.zhang.bio@gmail.com>
-     5	ZiWei <131428629+ZiWei09@users.noreply.github.com>
-     2	Junhan Chang <changjh@pku.edu.cn>
-     2	Xie Qiming <97236197+Andy6M@users.noreply.github.com>
-     1	Harvey Que <103566763+Mile-Away@users.noreply.github.com>
-     1	Junhan Chang <1700011741@pku.edu.cn>
-     1	LccLink <1951855008@qq.com>
-     1	h840473807 <47357934+h840473807@users.noreply.github.com>
-     1	lixinyu1011 <61094742+lixinyu1011@users.noreply.github.com>
-     1	shiyubo0410 <shiyubo@dp.tech>
-     1	王俊杰 <1800011822@pku.edu.cn>
-     1	王俊杰 <43375851+wjjxxx@users.noreply.github.com>

README.md

@@ -31,7 +31,7 @@ Join the [Intelligent Organic Chemistry Synthesis Competition](https://bohrium.d
 
 Detailed documentation can be found at:
 
-- [Online Documentation](https://dptech-corp.github.io/Uni-Lab-OS/)
+- [Online Documentation](https://readthedocs.dp.tech/Uni-Lab/v0.8.0/)
 
 ## Quick Start
 
@@ -55,7 +55,7 @@ pip install .
 
 3. Start Uni-Lab System:
 
-Please refer to [Documentation - Boot Examples](https://dptech-corp.github.io/Uni-Lab-OS/boot_examples/index.html)
+Please refer to [Documentation - Boot Examples](https://readthedocs.dp.tech/Uni-Lab/v0.8.0/boot_examples/index.html)
 
 ## Message Format
 

README_zh.md

@@ -31,7 +31,7 @@ Uni-Lab-OS 是一个用于实验室自动化的综合平台，旨在连接和控
 
 详细文档可在以下位置找到:
 
-- [在线文档](https://dptech-corp.github.io/Uni-Lab-OS/)
+- [在线文档](https://readthedocs.dp.tech/Uni-Lab/v0.8.0/)
 
 ## 快速开始
 
@@ -57,7 +57,7 @@ pip install .
 
 3. 启动 Uni-Lab 系统:
 
-请见[文档-启动样例](https://dptech-corp.github.io/Uni-Lab-OS/boot_examples/index.html)
+请见[文档-启动样例](https://readthedocs.dp.tech/Uni-Lab/v0.8.0/boot_examples/index.html)
 
 ## 消息格式
 

docs/boot_examples/liquid_handler.md

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

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

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

docs/developer_guide/add_action.md

@@ -127,16 +127,16 @@ add_action_files(
 ```bash
 mamba remove --force ros-humble-unilabos-msgs
 mamba config set safety_checks disabled  # 如果没有提升版本号，会触发md5与网络上md5不一致，是正常现象，因此通过本指令关闭md5检查
-mamba install xxx.conda --offline
+mamba install xxx.conda2 --offline
 ```
 
 ## 常见问题
 
-**Q: 构建失败怎么办？**
+**Q: 构建失败怎么办？**  
 A: 检查 Actions 日志中的错误信息，通常是语法错误或依赖问题。修复后重新推送代码即可自动触发新的构建。
 
-**Q: 如何测试特定平台？**
+**Q: 如何测试特定平台？**  
 A: 在手动触发构建时，在平台选择中只填写你需要的平台，如 `linux-64` 或 `win-64`。
 
-**Q: 构建包在哪里下载？**
+**Q: 构建包在哪里下载？**  
 A: 在 Actions 页面的构建结果中，查找 "Artifacts" 部分，每个平台都有对应的构建包可供下载。

docs/developer_guide/add_batteryPLC.md

@@ -1,147 +0,0 @@
-# 电池装配工站接入（PLC）
-
-本指南将引导你完成电池装配工站（以 PLC 控制为例）的接入流程，包括新建工站文件、编写驱动与寄存器读写、生成注册表、上传及注意事项。
-
-## 1. 新建工站文件
-
-### 1.1 创建工站文件
-
-在 `unilabos/devices/workstation/coin_cell_assembly` 目录下新建工站文件，如 `coin_cell_assembly.py`。工站类需继承 `WorkstationBase`，并在构造函数中初始化通信客户端与寄存器映射。
-
-```python
-from typing import Optional
-# 工站基类
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-# Modbus 通讯与寄存器 CSV 支持
-from unilabos.device_comms.modbus_plc.client import TCPClient, BaseClient
-
-class CoinCellAssemblyWorkstation(WorkstationBase):
-    def __init__(
-        self,
-        station_resource,
-        address: str = "192.168.1.20",
-        port: str = "502",
-        *args,
-        **kwargs,
-    ):
-        super().__init__(station_resource=station_resource, *args, **kwargs)
-        self.station_resource = station_resource  # 物料台面（Deck）
-        self.success: bool = False
-        self.allow_data_read: bool = False
-        self.csv_export_thread = None
-        self.csv_export_running = False
-        self.csv_export_file: Optional[str] = None
-
-        # 连接 PLC，并注册寄存器节点
-        tcp = TCPClient(addr=address, port=port)
-        tcp.client.connect()
-        self.nodes = BaseClient.load_csv(".../PLC_register.csv")
-        self.client = tcp.register_node_list(self.nodes)
-```
-
-
-
-## 2. 编写驱动与寄存器读写
-
-### 2.1 寄存器示例
-
-- `COIL_SYS_START_CMD`（BOOL，地址 8010）：启动命令（脉冲式）
-- `COIL_SYS_START_STATUS`（BOOL，地址 8210）：启动状态
-- `REG_DATA_OPEN_CIRCUIT_VOLTAGE`（FLOAT32，地址 10002）：开路电压
-- `REG_DATA_ASSEMBLY_PRESSURE`（INT16，地址 10014）：压制扣电压力
-
-### 2.2 最小驱动示例
-
-```python
-from unilabos.device_comms.modbus_plc.modbus import WorderOrder
-
-def start_and_read_metrics(self):
-    # 1) 下发启动（置 True 再复位 False）
-    self.client.use_node('COIL_SYS_START_CMD').write(True)
-    self.client.use_node('COIL_SYS_START_CMD').write(False)
-
-    # 2) 等待进入启动状态
-    while True:
-        status, _ = self.client.use_node('COIL_SYS_START_STATUS').read(1)
-        if bool(status[0]):
-            break
-
-    # 3) 读取关键数据（FLOAT32 需读 2 个寄存器并指定字节序）
-    voltage, _ = self.client.use_node('REG_DATA_OPEN_CIRCUIT_VOLTAGE').read(
-        2, word_order=WorderOrder.LITTLE
-    )
-    pressure, _ = self.client.use_node('REG_DATA_ASSEMBLY_PRESSURE').read(1)
-
-    return {
-        'open_circuit_voltage': voltage,
-        'assembly_pressure': pressure,
-    }
-```
-
-> 提示：若需参数下发，可在 PLC 端设置标志寄存器并完成握手复位，避免粘连与竞争。
-
-## 3. 本地生成注册表并校验
-
-完成工站类与驱动后，需要生成（或更新）工站注册表供系统识别。
-
-
-### 3.1 新增工站设备（或资源）首次生成注册表
-首先通过以下命令启动unilab。进入unilab系统状态检查页面
-
-```bash
-python unilabos\app\main.py -g celljson.json --ak <user的AK> --sk <user的SK>
-```
-
-点击注册表编辑，进入注册表编辑页面
-![Layers](image_add_batteryPLC/unilab_sys_status.png)
-
-按照图示步骤填写自动生成注册表信息：
-![Layers](image_add_batteryPLC/unilab_registry_process.png)
-
-步骤说明：
-1. 选择新增的工站`coin_cell_assembly.py`文件
-2. 点击分析按钮，分析`coin_cell_assembly.py`文件
-3. 选择`coin_cell_assembly.py`文件中继承`WorkstationBase`类
-4. 填写新增的工站.py文件与`unilabos`目录的距离。例如，新增的工站文件`coin_cell_assembly.py`路径为`unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly.py`，则此处填写`unilabos.devices.workstation.coin_cell_assembly`。
-5. 此处填写新定义工站的类的名字（名称可以自拟）
-6. 填写新的工站注册表备注信息
-7. 生成注册表
-
-以上操作步骤完成，则会生成的新的注册表ymal文件，如下图：
-![Layers](image_add_batteryPLC/unilab_new_yaml.png)
-
-
-
-
-
-
-### 3.2 添加新生成注册表
-在`unilabos\registry\devices`目录下新建一个yaml文件，此处新建文件命名为`coincellassemblyworkstation_device.yaml`，将上面生成的新的注册表信息粘贴到`coincellassemblyworkstation_device.yaml`文件中。   
-
-在终端输入以下命令进行注册表补全操作。
-```bash
-python unilabos\app\register.py --complete_registry
-```
-
-
-### 3.3 启动并上传注册表
-
-新增设备之后，启动unilab需要增加`--upload_registry`参数，来上传注册表信息。
-
-```bash
-python unilabos\app\main.py -g celljson.json --ak <user的AK> --sk <user的SK> --upload_registry
-```
-
-## 4. 注意事项
-
-- 在新生成的 YAML 中，确认 `module` 指向新工站类，本例中需检查`coincellassemblyworkstation_device.yaml`文件中是否指向了`coin_cell_assembly.py`文件中定义的`CoinCellAssemblyWorkstation`类文件：
-
-```
-module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinCellAssemblyWorkstation
-```
-
-- 首次新增设备（或资源）需要在网页端新增注册表信息，`--complete_registry`补全注册表，`--upload_registry`上传注册表信息。
-
-- 如果不是新增设备（或资源），仅对工站驱动的.py文件进行了修改，则不需要在网页端新增注册表信息。只需要运行补全注册表信息之后，上传注册表即可。
-
-

docs/developer_guide/add_device.md

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

docs/developer_guide/add_yaml.md

@@ -111,8 +111,8 @@ new_device: # 设备名，要唯一
 
 1. 以 `auto-` 开头的动作：从你 Python 类的方法自动生成
 2. 通用的驱动动作：
-   - `_execute_driver_command`：同步执行驱动命令（仅本地可用）
-   - `_execute_driver_command_async`：异步执行驱动命令（仅本地可用）
+   - `_execute_driver_command`：同步执行驱动命令
+   - `_execute_driver_command_async`：异步执行驱动命令
 
 ### 如果要手动定义动作
 

docs/developer_guide/materials_tutorial.md

@@ -1,409 +0,0 @@
-# 物料教程（Resource）
-
-本教程面向 Uni-Lab-OS 的开发者，讲解“物料”的核心概念、3种物料格式（UniLab、PyLabRobot、奔耀Bioyond）及其相互转换方法，并说明4种 children 结构表现形式及使用场景。
-
----
-
-## 1. 物料是什么
-
-- **物料（Resource）**：指实验工作站中的实体对象，包括设备（device）、操作甲板 （deck）、试剂、实验耗材，也包括设备上承载的具体物料或者包含的容器（如container/plate/well/瓶/孔/片等）。
-- **物料基本信息**（以 UniLab list格式为例）：
-
-```jsonc
-{
-    "id": "plate", // 某一类物料的唯一名称
-    "name": "50ml瓶装试剂托盘", // 在云端显示的名称
-    "sample_id": null, // 同类物料的不同样品
-    "children": [
-        "50ml试剂瓶"   // 表示托盘上有一个 50ml 试剂瓶
-    ],
-    "parent": "deck", // 此物料放置在 deck 上
-    "type": "plate", // 物料类型
-    "class": "plate", // 物料对应的注册/类名
-    "position": {
-        "x": 0, // 初始放置位置
-        "y": 0,
-        "z": 0
-    },
-    "config": { // 固有配置（尺寸、旋转等）
-        "size_x": 400.0,
-        "size_y": 400.0,
-        "size_z": 400.0,
-        "rotation": {
-            "x": 0,
-            "y": 0,
-            "z": 0,
-            "type": "Rotation"
-        }
-    },
-    "data": { 
-        "bottle_number": 1 // 动态数据（可变化）
-    }
-}
-```
-
-## 2. 3种物料格式概览(UniLab、PyLabRobot、奔耀Bioyond)
-
-### 2.1 UniLab 物料格式（云端/项目内通用）
-
-- 结构特征：顶层通常是 `nodes` 列表；每个节点是扁平字典，`children` 是子节点 `id` 列表；`parent` 为父节点 `id` 或 `null`。
-- 用途：
-  - 云端数据存储、前端可视化、与图结构算法互操作
-  - 在上传/下载/部署配置时作为标准交换格式
-
-示例片段（UniLab 物料格式）：
-
-```jsonc
-{
-  "nodes": [
-  
-    {
-      "id": "a",
-      "name": "name_a",
-      "sample_id": 1, 
-      "type": "deck",
-      "class": "deck",
-      "parent": null,
-      "children": ["b1"],
-      "position": {"x": 0, "y": 0, "z": 0},
-      "config": {},
-      "data": {}
-    },
-    {
-      
-      "id": "b1",
-      "name": "name_b1",
-      "sample_id": 1, 
-      "type": "plate",
-      "class": "plate",
-      "parent": "a1",
-      "children": [],
-      "position": {"x": 0, "y": 0, "z": 0},
-      "config": {},
-      "data": {}
-    }
-  ]
-}
-```
-
-### 2.2 PyLabRobot（PLR）物料格式（实验流程运行时）
-
-- 结构特征：严格的层级树，`children` 为“子资源字典列表”（每个子节点本身是完整对象）。
-- 用途：
-  - 实验流程执行与调度，PLR 运行时期望的资源对象格式
-  - 通过 `Resource.deserialize/serialize`、`load_all_state/serialize_all_state` 与对象交互
-
-示例片段（PRL 物料格式）：：
-
-```json
-{
-  "name": "deck",
-  "type": "Deck",
-  "category": "deck",
-  "location": {"x": 0, "y": 0, "z": 0, "type": "Coordinate"},
-  "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"},
-  "parent_name": null,
-  "children": [
-    {
-      "name": "plate_1",
-      "type": "Plate",
-      "category": "plate_96",
-      "location": {"x": 100, "y": 0, "z": 0, "type": "Coordinate"},
-      "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"},
-      "parent_name": "deck",
-      "children": [
-        {
-          "name": "A1",
-          "type": "Well",
-          "category": "well",
-          "location": {"x": 0, "y": 0, "z": 0, "type": "Coordinate"},
-          "rotation": {"x": 0, "y": 0, "z": 0, "type": "Rotation"},
-          "parent_name": "plate_1",
-          "children": []
-        }
-      ]
-    }
-  ]
-}
-```
-
-
-### 2.3 奔耀 Bioyond 物料格式（第三方来源）
-一般是厂商自己定义的json格式和字段，信息需要提取和对应。以下为示例说明。
-
-- 结构特征：顶层 `data` 列表，每项包含 `typeName`、`code`、`barCode`、`name`、`quantity`、`unit`、`locations`（仓位 `whName`、`x/y/z`）、`detail`（细粒度内容，如瓶内液体或孔位物料）。
-- 用途：
-  - 第三方 WMS/设备的物料清单输入
-  - 需要自定义映射表将 `typeName` → PLR 类名，对 `locations`/`detail` 进行落位/赋值
-
-示例片段（奔耀Bioyond 物料格式）：
-
-
-```json
-{
-  "data": [
-    {
-      "id": "3a1b5c10-d4f3-01ac-1e64-5b4be2add4b1",
-      "typeName": "液",
-      "code": "0006-00014",
-      "barCode": "",
-      "name": "EMC",
-      "quantity": 50,
-      "lockQuantity": 2.057,
-      "unit": "瓶",
-      "status": 1,
-      "isUse": false,
-      "locations": [
-        {
-          "id": "3a19da43-57b5-5e75-552f-8dbd0ad1075f",
-          "whid": "3a19da43-57b4-a2a8-3f52-91dbbeb836db",
-          "whName": "配液站内试剂仓库",
-          "code": "0003-0003",
-          "x": 1,
-          "y": 3,
-          "z": 1,
-          "quantity": 0
-        }
-      ],
-      "detail": [
-        {
-          "code": "0006-00014-01",
-          "name": "EMC-瓶-1",
-          "x": 1,
-          "y": 3,
-          "z": 1,
-          "quantity": 500.0
-        }
-      ]
-    }
-  ],
-  "code": 1,
-  "message": "",
-  "timestamp": 0
-}
-```
-### 2.4 3种物料格式关键字段对应(UniLab、PyLabRobot、奔耀Bioyond)
-
-| 含义 | UniLab | PyLabRobot (PLR) | 奔耀 Bioyond |
-| - | - | - | - |
-| 节点唯一名 | `id`  | `name` | `name` |
-| 父节点引用 | `parent` | `parent_name` | `locations` 坐标（无直接父名，需映射坐标下的物料） |
-| 子节点集合 | `children`（id 列表或对象列表，视结构而定） | `children`（对象列表） | `detail`（明细，非严格树结构，需要自定义映射） |
-| 类型（抽象类别） | `type`（device/container/plate/deck/…） | `category`（plate/well/…），以及类名 `type` | `typeName`（厂商自定义，如“液”、“加样头(大)”） |
-| 运行/业务数据 | `data` | 通过 `serialize_all_state()`/`load_all_state()` 管理的状态 | `quantity`、`lockQuantity` 等业务数值 |
-| 固有配置 | `config`（size_x/size_y/size_z/model/ordering…） | 资源字典中的同名键（反序列化时按构造签名取用） | 厂商自定义字段（需映射入 PLR/UniLab 的 `config` 或 `data`） |
-| 空间位置 | `position`（x/y/z） | `location`（Coordinate） + `rotation`（Rotation） | `locations`（whName、x/y/z），不含旋转 |
-| 条码/标识 | `config.barcode`（可选） | 常放在配置键中（如 `barcode`） | `barCode` |
-| 数量单位 | 无固定键，通常在 `data` | 无固定键，通常在配置或状态中 | `unit` |
-| 物料编码 | 通常在 `config` 或 `data` 自定义 | 通常在配置中自定义 | `code` |
-
-说明：
-- Bioyond 不提供显式的树形父子关系，通常通过 `locations` 将物料落位到某仓位/坐标。用 `detail` 表示子级明细。
-
----
-
-## 3. children 的四种结构表示
-
-- **list（扁平列表）**：每个节点是扁平字典，`children` 为子节点 `id` 数组。示例：UniLab `nodes` 中的单个节点。
-
-```json
-{
-  "nodes": [
-    { "id": "root", "parent": null, "children": ["child1"] },
-    { "id": "child1", "parent": "root", "children": [] }
-  ]
-}
-```
-- **dict（嵌套字典）**：节点的 `children` 是 `{ child_id: child_node_dict }` 字典。
-
-```json
-{
-  "id": "root",
-  "parent": null,
-  "children": {
-    "child1": { "id": "child1", "parent": "root", "children": {} }
-  }
-}
-```
-- **tree（树形列表）**：顶层是 `[root_node, ...]`，每个 `node.children` 是“子节点对象列表”（而非 id 列表）。
-
-```json
-[
-  {
-    "id": "root",
-    "parent": null,
-    "children": [
-      { "id": "child1", "parent": "root", "children": [] }
-    ]
-  }
-]
-```
-- **nestdict（顶层嵌套字典）**：顶层是 `{root_id: root_node, ...}`，或者根节点自身带 `children: {id: node}` 形态。
-
-```json
-{
-  "root": {
-    "id": "root",
-    "parent": null,
-    "children": {
-      "child1": { "id": "child1", "parent": "root", "children": {} }
-    }
-  }
-}
-```
-
-这些结构之间可使用 `graphio.py` 中的工具函数互转（见下一节）。
-
----
-
-## 4. 转换函数及调用
-
-核心代码文件：`unilabos/resources/graphio.py`
-
-### 4.1 结构互转（list/dict/tree/nestdict）
-
-代码引用：
-
-```217:239:unilabos/resources/graphio.py
-def dict_to_tree(nodes: dict, devices_only: bool = False) -> list[dict]:
-    # ... 由扁平 dict（id->node）生成树（children 为对象列表）
-```
-
-```241:267:unilabos/resources/graphio.py
-def dict_to_nested_dict(nodes: dict, devices_only: bool = False) -> dict:
-    # ... 由扁平 dict 生成嵌套字典（children 为 {id:node}）
-```
-
-```270:273:unilabos/resources/graphio.py
-def list_to_nested_dict(nodes: list[dict]) -> dict:
-    # ... 由扁平列表（children 为 id 列表）转嵌套字典
-```
-
-```275:286:unilabos/resources/graphio.py
-def tree_to_list(tree: list[dict]) -> list[dict]:
-    # ... 由树形列表转回扁平列表（children 还原为 id 列表）
-```
-
-```289:337:unilabos/resources/graphio.py
-def nested_dict_to_list(nested_dict: dict) -> list[dict]:
-    # ... 由嵌套字典转回扁平列表
-```
-
-常见路径：
-
-- UniLab 扁平列表 → 树：`dict_to_tree({r["id"]: r for r in resources})`
-- 树 → UniLab 扁平列表：`tree_to_list(resources_tree)`
-- 扁平列表 ↔ 嵌套字典：`list_to_nested_dict` / `nested_dict_to_list`
-
-### 4.2 UniLab ↔ PyLabRobot（PLR）
-
-高层封装：
-
-```339:368:unilabos/resources/graphio.py
-def convert_resources_to_type(resources_list: list[dict], resource_type: Union[type, list[type]], *, plr_model: bool = False):
-    # UniLab -> (NestedDict or PLR)
-```
-
-```371:395:unilabos/resources/graphio.py
-def convert_resources_from_type(resources_list, resource_type: Union[type, list[type]], *, is_plr: bool = False):
-    # (NestedDict or PLR) -> UniLab 扁平列表
-```
-
-底层转换：
-
-```398:441:unilabos/resources/graphio.py
-def resource_ulab_to_plr(resource: dict, plr_model=False) -> "ResourcePLR":
-    # UniLab 单节点(树根) -> PLR Resource 对象
-```
-
-```443:481:unilabos/resources/graphio.py
-def resource_plr_to_ulab(resource_plr: "ResourcePLR", parent_name: str = None, with_children=True):
-    # PLR Resource -> UniLab 单节点(dict)
-```
-
-示例：
-
-```python
-from unilabos.resources.graphio import convert_resources_to_type, convert_resources_from_type
-from pylabrobot.resources.resource import Resource as ResourcePLR
-
-# UniLab 扁平列表 -> PLR 根资源对象
-plr_root = convert_resources_to_type(resources_list=ulab_list, resource_type=ResourcePLR)
-
-# PLR 资源对象 -> UniLab 扁平列表（用于保存/上传）
-ulab_flat = convert_resources_from_type(resources_list=plr_root, resource_type=ResourcePLR)
-```
-
-可选项：
-
-- `plr_model=True`：保留 `model` 字段（默认会移除）。
-- `with_children=False`：`resource_plr_to_ulab` 仅转换当前节点。
-
-### 4.3 奔耀（Bioyond）→ PLR（及进一步到 UniLab）
-
-转换入口：
-
-```483:527:unilabos/resources/graphio.py
-def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: dict = {}, deck: Any = None) -> list[dict]:
-    # Bioyond 列表 -> PLR 资源列表，并可根据 deck.warehouses 将资源落位
-```
-
-使用示例：
-
-```python
-import json
-from unilabos.resources.graphio import resource_bioyond_to_plr, convert_resources_from_type
-from pylabrobot.resources.resource import Resource as ResourcePLR
-
-resp = json.load(open("unilabos/devices/workstation/bioyond_cell/bioyond_test_yibin.json", encoding="utf-8"))
-materials = resp["data"]
-
-# 将第三方类型name映射到 PLR 资源类名（需根据现场定义）
-type_mapping = {
-    "液": "RegularContainer",
-    "加样头(大)": "RegularContainer"
-}
-
-plr_list = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=None)
-
-# 如需上传云端（UniLab 扁平格式）：
-ulab_flat = convert_resources_from_type(plr_list, [ResourcePLR])
-```
-
-说明：
-
-- `type_mapping` 必须由开发者根据设备/物料种类人工维护。
-- 如传入 `deck`，且 `deck.warehouses` 命名与 `whName` 对应，可将物料安放到仓库坐标（x/y/z）。
-
----
-
-## 5. 何时使用哪种格式
-
-- **云端/持久化**：使用 UniLab 物料格式（扁平 `nodes` 列表，children 为 id 列表）。便于版本化、可视化与网络传输。
-- **实验工作流执行**：使用 PyLabRobot（PLR）格式。PLR 运行时依赖严格的树形资源结构与对象 API。
-- **第三方设备/系统（Bioyond）输入**：保持来源格式不变，使用 `resource_bioyond_to_plr` + 人工 `type_mapping` 将其转换为 PLR（必要时再转 UniLab）。
-
----
-
-## 6. 常见问题与注意事项
-
-- **children 形态不一致**：不同函数期望不同 children 形态，注意在进入转换前先用“结构互转”工具函数标准化形态。
-- **devices_only**：`dict_to_tree/dict_to_nested_dict` 支持仅保留 `type == device` 的节点。
-- **模型/类型字段**：PLR 对象序列化参数有所差异，`resource_ulab_to_plr` 内部会根据构造签名移除不兼容字段（如 `category`）。
-- **驱动初始化**：`initialize_resource(s)` 支持从注册表/类路径创建 PLR/UniLab 资源或列表。
-
-参考代码：
-
-```530:577:unilabos/resources/graphio.py
-def initialize_resource(resource_config: dict, resource_type: Any = None) -> Union[list[dict], ResourcePLR]:
-    # 从注册类/模块反射创建资源，或将 UniLab 字典包装为列表
-```
-
-```580:597:unilabos/resources/graphio.py
-def initialize_resources(resources_config) -> list[dict]:
-    # 批量初始化
-```
-
-
-
-

docs/developer_guide/workstation_architecture.md

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

docs/intro.md

@@ -33,8 +33,6 @@ developer_guide/add_device
 developer_guide/add_action
 developer_guide/actions
 developer_guide/add_protocol
-developer_guide/add_batteryPLC
-developer_guide/materials_tutorial.md
 ```
 
 ## 接口文档

docs/requirements.txt

@@ -1,13 +0,0 @@
-# Sphinx文档构建依赖
-sphinx>=7.0.0
-sphinx-rtd-theme>=2.0.0
-myst-parser>=2.0.0
-
-# 用于支持Jupyter notebook文档
-myst-nb>=1.0.0
-
-# 用于代码复制按钮
-sphinx-copybutton>=0.5.0
-
-# 用于自动摘要生成
-sphinx-autobuild>=2024.2.4

docs/user_guide/configuration.md

@@ -24,8 +24,6 @@ class WSConfig:
     max_reconnect_attempts = 999  # 最大重连次数
     ping_interval = 30  # ping间隔（秒）
 ```
-您可以进入实验室，点击左下角的头像在实验室详情中获取所在实验室的ak sk
-![copy_aksk.gif](image/copy_aksk.gif)
 
 ### 完整配置示例
 

docs/user_guide/installation.md

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

docs/user_guide/launch.md

@@ -245,78 +245,3 @@ unilab --ak your_ak --sk your_sk --port 8080 --disable_browser
 - 检查图谱文件格式是否正确
 - 验证设备连接和端点配置
 - 确保注册表路径正确
-
-## 页面操作
-
-### 1. 启动成功
-当您启动成功后，可以看到物料列表，节点模版和组态图如图展示
-![material.png](image/material.png)
-
-### 2. 根据需求创建设备和物料
-我们可以做一个简单的案例  
-* 在容器1中加入水  
-* 通过传输泵将容器1中的水转移到容器2中
-#### 2.1 添加所需的设备和物料  
-仪器设备work_station中的workstation 数量x1  
-仪器设备virtual_device中的virtual_transfer_pump 数量x1    
-物料耗材container中的container 数量x2  
-
-#### 2.2 将设备和物料根据父子关系进行关联  
-当我们添加设备时，仪器耗材模块的物料列表也会实时更新  
-我们需要将设备和物料拖拽到workstation中并在画布上将它们连接起来，就像真实的设备操作一样  
-![links.png](image/links.png)
-
-### 3. 创建工作流
-进入工作流模块 → 点击"我创建的" → 新建工作流
-![new.png](image/new.png)
-
-#### 3.1 新增工作流节点
-我们可以进入指定工作流，在空白处右键   
-* 选择Laboratory→host_node中的creat_resource
-* 选择Laboratory→workstation中的PumpTransferProtocol
-
-![creatworkfollow.gif](image/creatworkfollow.gif)
-
-#### 3.2 配置节点参数
-根据案例，工作流包含两个步骤：
-1. 使用creat_resource在容器中创建水
-2. 通过泵传输协议将水传输到另一个容器
-
-我们点击creat_resource卡片上的编辑按钮来配置参数⭐️  
-class_name ：container  
-device_id ： workstation  
-liquid_input_slot ： 0或-1均可  
-liquid_type : water  
-liquid_volume ： 根据需求填写即可，默认单位ml，这里举例50    
-parent ： workstation  
-res_id ： containe  
-关联设备名称(原unilabos_device_id) ： 这里就填写host_node  
-**配置完成后点击底部保存按钮**  
-
-我们点击PumpTransferProtocol卡片上的编辑按钮来配置参数⭐️  
-event ： transfer_liquid  
-from_vessel ： water  
-to_vessel ： container1  
-volume ： 根据需求填写即可，默认单位ml，这里举例50  
-关联设备名称(原unilabos_device_id) ： 这里就填写workstation  
-**配置完成后点击底部保存按钮**  
-
-#### 3.3 运行工作流
-1. 连接两个节点卡片
-2. 点击底部保存按钮
-3. 点击运行按钮执行工作流
-
-![linksandrun.png](image/linksandrun.png)
-
-### 运行监控
-* 运行状态和消息实时显示在底部控制台
-* 如有报错，可点击查看详细信息
-
-### 结果验证
-工作流完成后，返回仪器耗材模块：
-* 点击 container1卡片查看详情
-* 确认其中包含参数指定的水和容量
-
-
-
-

docs/user_guide/quick_install_guide.md

@@ -1,197 +0,0 @@
-# Uni-Lab-OS 一键安装快速指南
-
-## 概述
-
-本指南提供最快速的 Uni-Lab-OS 安装方法，使用预打包的 conda 环境，无需手动配置依赖。
-
-## 前置要求
-
-- 已安装 Conda/Miniconda/Miniforge/Mamba
-- 至少 10GB 可用磁盘空间
-- Windows 10+, macOS 10.14+, 或 Linux (Ubuntu 20.04+)
-
-## 安装步骤
-
-### 第一步：下载预打包环境
-
-1. 访问 [GitHub Actions - Conda Pack Build](https://github.com/dptech-corp/Uni-Lab-OS/actions/workflows/conda-pack-build.yml)
-
-2. 选择最新的成功构建记录（绿色勾号 ✓）
-
-3. 在页面底部的 "Artifacts" 部分，下载对应你操作系统的压缩包：
-   - Windows: `unilab-pack-win-64-{branch}.zip`
-   - macOS (Intel): `unilab-pack-osx-64-{branch}.tar.gz`
-   - macOS (Apple Silicon): `unilab-pack-osx-arm64-{branch}.tar.gz`
-   - Linux: `unilab-pack-linux-64-{branch}.tar.gz`
-
-### 第二步：解压并运行安装脚本
-
-#### Windows
-
-```batch
-REM 使用 Windows 资源管理器解压下载的 zip 文件
-REM 或使用命令行：
-tar -xzf unilab-pack-win-64-dev.zip
-
-REM 进入解压后的目录
-cd unilab-pack-win-64-dev
-
-REM 双击运行 install_unilab.bat
-REM 或在命令行中执行：
-install_unilab.bat
-```
-
-#### macOS
-
-```bash
-# 解压下载的压缩包
-tar -xzf unilab-pack-osx-arm64-dev.tar.gz
-
-# 进入解压后的目录
-cd unilab-pack-osx-arm64-dev
-
-# 运行安装脚本
-bash install_unilab.sh
-```
-
-#### Linux
-
-```bash
-# 解压下载的压缩包
-tar -xzf unilab-pack-linux-64-dev.tar.gz
-
-# 进入解压后的目录
-cd unilab-pack-linux-64-dev
-
-# 添加执行权限（如果需要）
-chmod +x install_unilab.sh
-
-# 运行安装脚本
-./install_unilab.sh
-```
-
-### 第三步：激活环境
-
-```bash
-conda activate unilab
-```
-
-### 第四步：验证安装（推荐）
-
-```bash
-# 确保已激活环境
-conda activate unilab
-
-# 运行验证脚本
-python verify_installation.py
-```
-
-如果看到 "✓ All checks passed!"，说明安装成功！
-
-## 常见问题
-
-### Q: 安装脚本找不到 conda？
-
-**A:** 确保你已经安装了 conda/miniconda/miniforge，并且安装在标准位置：
-
-- **Windows**:
-
-  - `%USERPROFILE%\miniforge3`
-  - `%USERPROFILE%\miniconda3`
-  - `%USERPROFILE%\anaconda3`
-  - `C:\ProgramData\miniforge3`
-
-- **macOS/Linux**:
-  - `~/miniforge3`
-  - `~/miniconda3`
-  - `~/anaconda3`
-  - `/opt/conda`
-
-如果安装在其他位置，可以先激活 conda base 环境，然后手动运行安装脚本。
-
-### Q: 安装后激活环境提示找不到？
-
-**A:** 尝试以下方法：
-
-```bash
-# 方法 1: 使用 conda activate
-conda activate unilab
-
-# 方法 2: 使用完整路径激活（Windows）
-call C:\Users\{YourUsername}\miniforge3\envs\unilab\Scripts\activate.bat
-
-# 方法 2: 使用完整路径激活（Unix）
-source ~/miniforge3/envs/unilab/bin/activate
-```
-
-### Q: conda-unpack 失败怎么办？
-
-**A:** 尝试手动运行：
-
-```bash
-# Windows
-cd %CONDA_PREFIX%\envs\unilab
-.\Scripts\conda-unpack.exe
-
-# macOS/Linux
-cd $CONDA_PREFIX/envs/unilab
-./bin/conda-unpack
-```
-
-### Q: 验证脚本报错？
-
-**A:** 首先确认环境已激活：
-
-```bash
-# 检查当前环境
-conda env list
-
-# 应该看到 unilab 前面有 * 标记
-```
-
-如果仍有问题，查看具体报错信息，可能需要：
-
-- 重新运行安装脚本
-- 检查磁盘空间
-- 查看详细文档
-
-### Q: 环境很大，有办法减小吗？
-
-**A:** 预打包的环境包含所有依赖，通常较大（压缩后 2-5GB）。这是为了确保离线安装和完整功能。如果空间有限，考虑使用手动安装方式，只安装需要的组件。
-
-### Q: 如何更新到最新版本？
-
-**A:** 重新下载最新的预打包环境，运行安装脚本时选择覆盖现有环境。
-
-或者在现有环境中更新：
-
-```bash
-conda activate unilab
-
-# 更新 unilabos
-cd /path/to/Uni-Lab-OS
-git pull
-pip install -e . --upgrade
-
-# 更新 ros-humble-unilabos-msgs
-mamba update ros-humble-unilabos-msgs -c uni-lab -c robostack-staging -c conda-forge
-```
-
-## 下一步
-
-安装完成后，你可以：
-
-1. **查看启动指南**: {doc}`launch`
-2. **运行示例**: {doc}`../boot_examples/index`
-3. **配置设备**: 编辑 `unilabos_data/startup_config.json`
-4. **阅读开发文档**: {doc}`../developer_guide/workstation_architecture`
-
-## 需要帮助？
-
-- **文档**: [docs/user_guide/installation.md](installation.md)
-- **问题反馈**: [GitHub Issues](https://github.com/dptech-corp/Uni-Lab-OS/issues)
-- **开发版安装**: 参考 {doc}`installation` 的方式二
-
----
-
-**提示**: 这个预打包环境包含了从指定分支（通常是 `dev`）构建的最新代码。如果需要稳定版本，请使用方式二手动安装 release 版本。

package.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>unilabos</name>
+  <version>0.0.0</version>
+  <description>ROS2 package for unilabos server</description>
+  <maintainer email="changjh@pku.edu.cn">changjh</maintainer>
+  <license>TODO: License declaration</license>
+
+  <build_depend>action_msgs</build_depend>
+  <exec_depend>action_msgs</exec_depend>
+  <member_of_group>rosidl_interface_packages</member_of_group>
+
+  <test_depend>ament_copyright</test_depend>
+  <test_depend>ament_flake8</test_depend>
+  <test_depend>ament_pep257</test_depend>
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

scripts/create_readme.py

@@ -1,190 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create Distribution Package README
-===================================
-
-Generate README.txt for conda-pack distribution packages.
-
-Usage:
-    python create_readme.py <platform> <branch> <output_file>
-
-Arguments:
-    platform: Platform identifier (win-64, linux-64, osx-64, osx-arm64)
-    branch: Git branch name
-    output_file: Output file path (e.g., dist-package/README.txt)
-
-Example:
-    python create_readme.py win-64 dev dist-package/README.txt
-"""
-
-import argparse
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-def get_readme_content(platform: str, branch: str) -> str:
-    """
-    Generate README content for the specified platform.
-
-    Args:
-        platform: Platform identifier
-        branch: Git branch name
-
-    Returns:
-        str: README content
-    """
-    # Get current UTC time
-    build_date = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
-
-    # Determine platform-specific content
-    is_windows = platform == "win-64"
-
-    if is_windows:
-        archive_ext = "zip"
-        install_script = "install_unilab.bat"
-        platform_instructions = """Windows:
-  1. Extract the downloaded ZIP file
-  2. Double-click install_unilab.bat (or run in cmd)
-  3. Follow the prompts"""
-    else:
-        archive_ext = "tar.gz"
-        install_script = "install_unilab.sh"
-        platform_name = {"linux-64": "linux-64", "osx-64": "osx-64", "osx-arm64": "osx-arm64"}.get(platform, platform)
-        platform_instructions = f"""macOS/Linux:
-  1. Download and extract unilab-pack-{platform_name}.tar.gz
-  2. Run: bash install_unilab.sh
-  3. Follow the prompts
-  
-  Alternative (if downloaded from GitHub Actions):
-  1. Extract the artifact ZIP file
-  2. Extract unilab-pack-{platform_name}.tar.gz inside
-  3. Run: bash install_unilab.sh"""
-
-    # Generate README content
-    readme = f"""UniLabOS Conda-Pack Environment
-================================
-
-This package contains a pre-built UniLabOS environment.
-
-Installation Instructions:
---------------------------
-
-{platform_instructions}
-
-The installation script will:
-  - Automatically find your conda installation
-  - Extract the environment to conda's envs/unilab directory
-  - Run conda-unpack to finalize setup
-
-After installation:
-  conda activate unilab
-  python verify_installation.py
-
-Verification:
--------------
-
-The verify_installation.py script will check:
-  - Python version (3.11.11)
-  - ROS2 rclpy installation
-  - UniLabOS installation and dependencies
-
-If all checks pass, you're ready to use UniLabOS!
-
-Package Contents:
------------------
-
-  - {install_script} (automatic installation script)
-  - unilab-env-{platform}.tar.gz (packed conda environment)
-  - verify_installation.py (environment verification tool)
-  - README.txt (this file)
-
-Build Information:
-------------------
-
-  Branch:   {branch}
-  Platform: {platform}
-  Python:   3.11.11
-  Date:     {build_date}
-
-Troubleshooting:
-----------------
-
-If installation fails:
-
-  1. Ensure conda or mamba is installed
-     Check: conda --version
-
-  2. Verify you have sufficient disk space
-     Required: ~5-10 GB after extraction
-
-  3. Check installation permissions
-     You need write access to conda's envs directory
-
-  4. For detailed logs, run the install script from terminal
-
-For more help:
-  - Documentation: docs/user_guide/installation.md
-  - Quick Start: QUICK_START_CONDA_PACK.md
-  - Issues: https://github.com/dptech-corp/Uni-Lab-OS/issues
-
-License:
---------
-
-UniLabOS is licensed under GPL-3.0-only.
-See LICENSE file for details.
-
-Repository: https://github.com/dptech-corp/Uni-Lab-OS
-"""
-
-    return readme
-
-
-def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Generate README.txt for conda-pack distribution",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python create_readme.py win-64 dev dist-package/README.txt
-  python create_readme.py linux-64 main dist-package/README.txt
-        """,
-    )
-
-    parser.add_argument("platform", choices=["win-64", "linux-64", "osx-64", "osx-arm64"], help="Platform identifier")
-
-    parser.add_argument("branch", help="Git branch name")
-
-    parser.add_argument("output_file", help="Output file path")
-
-    args = parser.parse_args()
-
-    try:
-        # Generate README content
-        readme_content = get_readme_content(args.platform, args.branch)
-
-        # Create output directory if needed
-        output_path = Path(args.output_file)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Write README file
-        with open(output_path, "w", encoding="utf-8") as f:
-            f.write(readme_content)
-
-        print(f"✓ README.txt created: {output_path}")
-        print(f"  Platform: {args.platform}")
-        print(f"  Branch:   {args.branch}")
-
-        return 0
-
-    except Exception as e:
-        print(f"Error creating README: {e}", file=sys.stderr)
-        import traceback
-
-        traceback.print_exc()
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/create_zip_archive.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create ZIP Archive with ZIP64 Support
-======================================
-
-This script creates a ZIP archive with ZIP64 support for large files (>2GB).
-It's used in the conda-pack build workflow to package the distribution.
-
-PowerShell's Compress-Archive has a 2GB limitation, so we use Python's zipfile
-module with allowZip64=True to handle large conda-packed environments.
-
-Usage:
-    python create_zip_archive.py <source_dir> <output_zip> [--compression-level LEVEL]
-
-Arguments:
-    source_dir: Directory to compress
-    output_zip: Output ZIP file path
-    --compression-level: Compression level (0-9, default: 6)
-
-Example:
-    python create_zip_archive.py dist-package unilab-pack-win-64.zip
-"""
-
-import argparse
-import os
-import sys
-import zipfile
-from pathlib import Path
-
-
-def create_zip_archive(source_dir: str, output_zip: str, compression_level: int = 6) -> bool:
-    """
-    Create a ZIP archive with ZIP64 support.
-
-    Args:
-        source_dir: Directory to compress
-        output_zip: Output ZIP file path
-        compression_level: Compression level (0-9)
-
-    Returns:
-        bool: True if successful
-    """
-    try:
-        source_path = Path(source_dir)
-        output_path = Path(output_zip)
-
-        # Validate source directory
-        if not source_path.exists():
-            print(f"Error: Source directory does not exist: {source_dir}", file=sys.stderr)
-            return False
-
-        if not source_path.is_dir():
-            print(f"Error: Source path is not a directory: {source_dir}", file=sys.stderr)
-            return False
-
-        # Remove existing output file if present
-        if output_path.exists():
-            print(f"Removing existing archive: {output_path}")
-            output_path.unlink()
-
-        # Create ZIP archive
-        print("=" * 70)
-        print(f"Creating ZIP archive with ZIP64 support")
-        print(f"  Source: {source_path.absolute()}")
-        print(f"  Output: {output_path.absolute()}")
-        print(f"  Compression: Level {compression_level}")
-        print("=" * 70)
-
-        total_size = 0
-        file_count = 0
-
-        with zipfile.ZipFile(
-            output_path, "w", zipfile.ZIP_DEFLATED, allowZip64=True, compresslevel=compression_level
-        ) as zipf:
-            # Walk through source directory
-            for root, dirs, files in os.walk(source_dir):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    arcname = os.path.relpath(file_path, source_dir)
-                    file_size = os.path.getsize(file_path)
-
-                    # Add file to archive
-                    zipf.write(file_path, arcname)
-
-                    # Display progress
-                    total_size += file_size
-                    file_count += 1
-                    print(f"  [{file_count:3d}] Adding: {arcname:50s} {file_size:>15,} bytes")
-
-        # Get final archive size
-        archive_size = output_path.stat().st_size
-        compression_ratio = (1 - archive_size / total_size) * 100 if total_size > 0 else 0
-
-        # Display summary
-        print("=" * 70)
-        print("Archive created successfully!")
-        print(f"  Files added: {file_count}")
-        print(f"  Total size (uncompressed): {total_size:>15,} bytes ({total_size / (1024**3):.2f} GB)")
-        print(f"  Archive size (compressed):  {archive_size:>15,} bytes ({archive_size / (1024**3):.2f} GB)")
-        print(f"  Compression ratio: {compression_ratio:.1f}%")
-        print("=" * 70)
-
-        return True
-
-    except Exception as e:
-        print(f"Error creating ZIP archive: {e}", file=sys.stderr)
-        import traceback
-
-        traceback.print_exc()
-        return False
-
-
-def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Create ZIP archive with ZIP64 support for large files",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python create_zip_archive.py dist-package unilab-pack-win-64.zip
-  python create_zip_archive.py dist-package unilab-pack-win-64.zip --compression-level 9
-        """,
-    )
-
-    parser.add_argument("source_dir", help="Directory to compress")
-
-    parser.add_argument("output_zip", help="Output ZIP file path")
-
-    parser.add_argument(
-        "--compression-level",
-        type=int,
-        default=6,
-        choices=range(0, 10),
-        metavar="LEVEL",
-        help="Compression level (0=no compression, 9=maximum compression, default=6)",
-    )
-
-    args = parser.parse_args()
-
-    # Create archive
-    success = create_zip_archive(args.source_dir, args.output_zip, args.compression_level)
-
-    # Exit with appropriate code
-    sys.exit(0 if success else 1)
-
-
-if __name__ == "__main__":
-    main()

scripts/install_unilab.bat

@@ -1,203 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-
-echo ================================================
-echo UniLabOS Environment Installation Script
-echo ================================================
-echo.
-
-REM Get the directory where this script is located
-set "SCRIPT_DIR=%~dp0"
-cd /d "%SCRIPT_DIR%"
-
-REM Find conda installation
-echo Searching for conda installation...
-
-REM Method 1: Try to get conda base using 'conda info --base'
-set "CONDA_BASE="
-for /f "tokens=*" %%i in ('conda info --base 2^>nul') do (
-    set "CONDA_BASE=%%i"
-)
-
-if not "%CONDA_BASE%"=="" (
-    echo Found conda at: %CONDA_BASE% (via conda info)
-    goto :conda_found
-)
-
-REM Method 2: Use 'where conda' and parse the path
-echo Trying alternative method...
-for /f "tokens=*" %%i in ('where conda 2^>nul') do (
-    set "CONDA_PATH=%%i"
-    goto :parse_conda_path
-)
-
-echo ERROR: Could not find conda installation!
-echo Please make sure conda/mamba is installed and in your PATH.
-echo.
-pause
-exit /b 1
-
-:parse_conda_path
-REM Parse conda path to find base directory
-REM Common paths:
-REM   C:\Users\hp\miniforge3\Library\bin\conda.bat
-REM   C:\Users\hp\miniforge3\Scripts\conda.exe
-REM   C:\Users\hp\miniforge3\condabin\conda.bat
-
-echo Found conda executable at: %CONDA_PATH%
-
-REM Check if path contains \Library\bin\ (typical for conda.bat)
-echo %CONDA_PATH% | findstr /C:"\Library\bin\" >nul
-if not errorlevel 1 (
-    REM Path like: C:\Users\hp\miniforge3\Library\bin\conda.bat
-    REM Need to go up 3 levels: bin -> Library -> miniforge3
-    for %%i in ("%CONDA_PATH%") do set "CONDA_BASE=%%~dpi"
-    for %%i in ("%CONDA_BASE%..\..\..") do set "CONDA_BASE=%%~fi"
-    goto :conda_found
-)
-
-REM Check if path contains \Scripts\ (typical for conda.exe)
-echo %CONDA_PATH% | findstr /C:"\Scripts\" >nul
-if not errorlevel 1 (
-    REM Path like: C:\Users\hp\miniforge3\Scripts\conda.exe
-    REM Need to go up 2 levels: Scripts -> miniforge3
-    for %%i in ("%CONDA_PATH%") do set "CONDA_BASE=%%~dpi"
-    for %%i in ("%CONDA_BASE%..\.") do set "CONDA_BASE=%%~fi"
-    goto :conda_found
-)
-
-REM Check if path contains \condabin\ (typical for conda.bat)
-echo %CONDA_PATH% | findstr /C:"\condabin\" >nul
-if not errorlevel 1 (
-    REM Path like: C:\Users\hp\miniforge3\condabin\conda.bat
-    REM Need to go up 2 levels: condabin -> miniforge3
-    for %%i in ("%CONDA_PATH%") do set "CONDA_BASE=%%~dpi"
-    for %%i in ("%CONDA_BASE%..\.") do set "CONDA_BASE=%%~fi"
-    goto :conda_found
-)
-
-REM Default: assume it's 2 levels up
-for %%i in ("%CONDA_PATH%") do set "CONDA_BASE=%%~dpi"
-for %%i in ("%CONDA_BASE%..\.") do set "CONDA_BASE=%%~fi"
-
-:conda_found
-echo Found conda base directory: %CONDA_BASE%
-echo.
-
-REM Set target environment path
-set "ENV_NAME=unilab"
-set "ENV_PATH=%CONDA_BASE%\envs\%ENV_NAME%"
-
-REM Check if environment already exists
-if exist "%ENV_PATH%" (
-    echo WARNING: Environment '%ENV_NAME%' already exists at %ENV_PATH%
-    echo.
-    set /p "OVERWRITE=Do you want to overwrite it? (y/n): "
-    if /i not "!OVERWRITE!"=="y" (
-        echo Installation cancelled.
-        pause
-        exit /b 0
-    )
-    echo Removing existing environment...
-    rmdir /s /q "%ENV_PATH%"
-)
-
-REM Find the packed environment file
-set "PACK_FILE="
-for %%f in (unilab-env*.tar.gz) do (
-    set "PACK_FILE=%%f"
-    goto :found_pack
-)
-
-:found_pack
-if "%PACK_FILE%"=="" (
-    echo ERROR: Could not find unilab-env*.tar.gz file!
-    echo Please make sure the packed environment file is in the same directory as this script.
-    echo.
-    pause
-    exit /b 1
-)
-
-echo Found packed environment: %PACK_FILE%
-echo.
-
-REM Extract the packed environment
-echo Extracting environment to %ENV_PATH%...
-mkdir "%ENV_PATH%"
-
-REM Extract using tar (available in Windows 10+)
-tar -xzf "%PACK_FILE%" -C "%ENV_PATH%"
-if errorlevel 1 (
-    echo ERROR: Failed to extract environment!
-    echo Make sure you have Windows 10 or later with tar support.
-    pause
-    exit /b 1
-)
-
-echo.
-echo Unpacking conda environment...
-echo Changing to environment directory: %ENV_PATH%
-cd /d "%ENV_PATH%"
-
-REM Run conda-unpack from the environment directory
-if exist "Scripts\conda-unpack.exe" (
-    echo Running: .\Scripts\conda-unpack.exe
-    .\Scripts\conda-unpack.exe
-) else if exist "Scripts\activate.bat" (
-    echo Running: .\Scripts\activate.bat followed by conda-unpack
-    call .\Scripts\activate.bat
-    conda-unpack
-) else (
-    echo ERROR: Could not find Scripts\conda-unpack.exe or Scripts\activate.bat!
-    echo Current directory: %CD%
-    echo Expected location: %ENV_PATH%\Scripts\
-    pause
-    exit /b 1
-)
-
-if errorlevel 1 (
-    echo ERROR: conda-unpack failed!
-    pause
-    exit /b 1
-)
-
-echo.
-echo Checking UniLabOS entry point...
-REM Check if unilab-script.py exists
-set "UNILAB_SCRIPT=%ENV_PATH%\Scripts\unilab-script.py"
-if not exist "%UNILAB_SCRIPT%" (
-    echo WARNING: unilab-script.py not found, creating it...
-    (
-        echo # -*- coding: utf-8 -*-
-        echo import re
-        echo import sys
-        echo.
-        echo from unilabos.app.main import main
-        echo.
-        echo if __name__ == '__main__':
-        echo     sys.argv[0] = re.sub^(r'(-script\.pyw?^|\.exe^)?$', '', sys.argv[0]^)
-        echo     sys.exit^(main^(^)^)
-    ) > "%UNILAB_SCRIPT%"
-    echo Created: %UNILAB_SCRIPT%
-) else (
-    echo Found: %UNILAB_SCRIPT%
-)
-
-echo.
-echo ================================================
-echo Installation completed successfully!
-echo ================================================
-echo.
-echo To activate the environment, run:
-echo   conda activate %ENV_NAME%
-echo.
-echo or
-echo.
-echo   call %ENV_PATH%\Scripts\activate.bat
-echo.
-echo You can verify the installation by running:
-echo   cd /d "%SCRIPT_DIR%"
-echo   python verify_installation.py
-echo.
-pause
-

scripts/install_unilab.sh

@@ -1,139 +0,0 @@
-#!/bin/bash
-set -e
-
-echo "================================================"
-echo "UniLabOS Environment Installation Script"
-echo "================================================"
-echo ""
-
-# Get the directory where this script is located
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-cd "$SCRIPT_DIR"
-
-# Find conda installation
-echo "Searching for conda installation..."
-CONDA_BASE=""
-
-# Try to find conda in PATH
-if command -v conda &> /dev/null; then
-    CONDA_BASE=$(conda info --base)
-    echo "Found conda at: $CONDA_BASE"
-elif [ -d "$HOME/miniforge3" ]; then
-    CONDA_BASE="$HOME/miniforge3"
-    echo "Found conda at: $CONDA_BASE"
-elif [ -d "$HOME/miniconda3" ]; then
-    CONDA_BASE="$HOME/miniconda3"
-    echo "Found conda at: $CONDA_BASE"
-elif [ -d "$HOME/anaconda3" ]; then
-    CONDA_BASE="$HOME/anaconda3"
-    echo "Found conda at: $CONDA_BASE"
-elif [ -d "/opt/conda" ]; then
-    CONDA_BASE="/opt/conda"
-    echo "Found conda at: $CONDA_BASE"
-else
-    echo "ERROR: Could not find conda installation!"
-    echo "Please make sure conda/mamba is installed."
-    exit 1
-fi
-
-echo ""
-
-# Initialize conda for this shell
-if [ -f "$CONDA_BASE/etc/profile.d/conda.sh" ]; then
-    source "$CONDA_BASE/etc/profile.d/conda.sh"
-fi
-
-# Set target environment path
-ENV_NAME="unilab"
-ENV_PATH="$CONDA_BASE/envs/$ENV_NAME"
-
-# Check if environment already exists
-if [ -d "$ENV_PATH" ]; then
-    echo "WARNING: Environment '$ENV_NAME' already exists at $ENV_PATH"
-    read -p "Do you want to overwrite it? (y/n): " OVERWRITE
-    if [ "$OVERWRITE" != "y" ] && [ "$OVERWRITE" != "Y" ]; then
-        echo "Installation cancelled."
-        exit 0
-    fi
-    echo "Removing existing environment..."
-    rm -rf "$ENV_PATH"
-fi
-
-# Find the packed environment file
-PACK_FILE=$(ls unilab-env*.tar.gz 2>/dev/null | head -n 1)
-
-if [ -z "$PACK_FILE" ]; then
-    echo "ERROR: Could not find unilab-env*.tar.gz file!"
-    echo "Please make sure the packed environment file is in the same directory as this script."
-    exit 1
-fi
-
-echo "Found packed environment: $PACK_FILE"
-echo ""
-
-# Extract the packed environment
-echo "Extracting environment to $ENV_PATH..."
-mkdir -p "$ENV_PATH"
-tar -xzf "$PACK_FILE" -C "$ENV_PATH"
-
-echo ""
-echo "Unpacking conda environment..."
-echo "Changing to environment directory: $ENV_PATH"
-cd "$ENV_PATH"
-
-# Run conda-unpack from the environment directory
-if [ -f "bin/conda-unpack" ]; then
-    echo "Running: ./bin/conda-unpack"
-    ./bin/conda-unpack
-elif [ -f "bin/activate" ]; then
-    echo "Running: source bin/activate followed by conda-unpack"
-    source bin/activate
-    conda-unpack
-else
-    echo "ERROR: Could not find bin/conda-unpack or bin/activate!"
-    echo "Current directory: $(pwd)"
-    echo "Expected location: $ENV_PATH/bin/"
-    exit 1
-fi
-
-echo ""
-echo "Checking UniLabOS entry point..."
-# Check if unilab script exists in bin directory
-UNILAB_SCRIPT="$ENV_PATH/bin/unilab"
-if [ ! -f "$UNILAB_SCRIPT" ]; then
-    echo "WARNING: unilab script not found, creating it..."
-    cat > "$UNILAB_SCRIPT" << 'EOF'
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from unilabos.app.main import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
-EOF
-    chmod +x "$UNILAB_SCRIPT"
-    echo "Created: $UNILAB_SCRIPT"
-else
-    echo "Found: $UNILAB_SCRIPT"
-fi
-
-echo ""
-echo "================================================"
-echo "Installation completed successfully!"
-echo "================================================"
-echo ""
-echo "To activate the environment, run:"
-echo "  conda activate $ENV_NAME"
-echo ""
-echo "or"
-echo ""
-echo "  source $ENV_PATH/bin/activate"
-echo ""
-echo "You can verify the installation by running:"
-echo "  cd $SCRIPT_DIR"
-echo "  python verify_installation.py"
-echo ""
-

scripts/verify_installation.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-UniLabOS Installation Verification Script
-=========================================
-
-This script verifies that UniLabOS and its dependencies are correctly installed.
-Run this script after installing the conda-pack environment to ensure everything works.
-
-Usage:
-    python verify_installation.py
-
-    Or in the conda environment:
-    conda activate unilab
-    python verify_installation.py
-"""
-
-import sys
-import os
-
-# IMPORTANT: Set UTF-8 encoding BEFORE any other imports
-# This ensures all subsequent imports (including unilabos) can output UTF-8 characters
-if sys.platform == "win32":
-    # Method 1: Reconfigure stdout/stderr to use UTF-8 with error handling
-    try:
-        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
-    except (AttributeError, OSError):
-        pass
-
-    # Method 2: Set environment variable for subprocess and console
-    os.environ["PYTHONIOENCODING"] = "utf-8"
-
-    # Method 3: Try to change Windows console code page to UTF-8
-    try:
-        import ctypes
-
-        # Set console code page to UTF-8 (CP 65001)
-        ctypes.windll.kernel32.SetConsoleCP(65001)
-        ctypes.windll.kernel32.SetConsoleOutputCP(65001)
-    except (ImportError, AttributeError, OSError):
-        pass
-
-# Now import other modules
-import importlib
-
-# Use ASCII-safe symbols that work across all platforms
-CHECK_MARK = "[OK]"
-CROSS_MARK = "[FAIL]"
-
-
-def check_package(package_name: str, display_name: str = None) -> bool:
-    """
-    Check if a package can be imported.
-
-    Args:
-        package_name: Name of the package to import
-        display_name: Display name (defaults to package_name)
-
-    Returns:
-        bool: True if package is available
-    """
-    if display_name is None:
-        display_name = package_name
-
-    try:
-        importlib.import_module(package_name)
-        print(f"  {CHECK_MARK} {display_name}")
-        return True
-    except ImportError:
-        print(f"  {CROSS_MARK} {display_name}")
-        return False
-
-
-def check_python_version() -> bool:
-    """Check Python version."""
-    version = sys.version_info
-    version_str = f"{version.major}.{version.minor}.{version.micro}"
-
-    if version.major == 3 and version.minor >= 11:
-        print(f"  {CHECK_MARK} Python {version_str}")
-        return True
-    else:
-        print(f"  {CROSS_MARK} Python {version_str} (requires Python 3.11+)")
-        return False
-
-
-def main():
-    """Run all verification checks."""
-    print("=" * 60)
-    print("UniLabOS Installation Verification")
-    print("=" * 60)
-    print()
-
-    all_passed = True
-
-    # Check Python version
-    print("Checking Python version...")
-    if not check_python_version():
-        all_passed = False
-    print()
-
-    # Check ROS2 rclpy
-    print("Checking ROS2 rclpy...")
-    if not check_package("rclpy", "ROS2 rclpy"):
-        all_passed = False
-    print()
-
-    # Run environment checker from unilabos
-    print("Checking UniLabOS and dependencies...")
-    try:
-        from unilabos.utils.environment_check import check_environment
-
-        print(f"  {CHECK_MARK} UniLabOS installed")
-
-        # Check environment without auto-install (verification only)
-        # Set show_details=False to suppress detailed Chinese output that may cause encoding issues
-        env_check_passed = check_environment(auto_install=False, show_details=False)
-
-        if env_check_passed:
-            print(f"  {CHECK_MARK} All required packages available")
-        else:
-            print(f"  {CROSS_MARK} Some optional packages are missing")
-    except ImportError:
-        print(f"  {CROSS_MARK} UniLabOS not installed")
-        all_passed = False
-    except Exception as e:
-        print(f"  {CROSS_MARK} Environment check failed: {str(e)}")
-    print()
-
-    # Summary
-    print("=" * 60)
-    print("Verification Summary")
-    print("=" * 60)
-
-    if all_passed:
-        print(f"\n{CHECK_MARK} All checks passed! Your UniLabOS installation is ready.")
-        print("\nNext steps:")
-        print("  1. Review the documentation: docs/user_guide/launch.md")
-        print("  2. Try the examples: docs/boot_examples/")
-        print("  3. Configure your devices: unilabos_data/startup_config.json")
-        return 0
-    else:
-        print(f"\n{CROSS_MARK} Some checks failed. Please review the errors above.")
-        print("\nTroubleshooting:")
-        print("  1. Ensure you're in the correct conda environment: conda activate unilab")
-        print("  2. Check the installation documentation: docs/user_guide/installation.md")
-        print("  3. Try reinstalling: pip install .")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

setup.py

@@ -4,14 +4,13 @@ package_name = 'unilabos'
 
 setup(
     name=package_name,
-    version='0.10.7',
+    version='0.10.5',
     packages=find_packages(),
     include_package_data=True,
     install_requires=['setuptools'],
     zip_safe=True,
-    author="The unilabos developers",
-    maintainer='Junhan Chang, Xuwznln',
-    maintainer_email='Junhan Chang <changjh@pku.edu.cn>, Xuwznln <18435084+Xuwznln@users.noreply.github.com>',
+    maintainer='Junhan Chang',
+    maintainer_email='changjh@pku.edu.cn',
     description='',
     license='GPL v3',
     tests_require=['pytest'],

test/experiments/dispensing_station_bioyond.json

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

test/experiments/laiyu_liquid.json

@@ -1,148 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "laiyu_liquid_station",
-            "name": "LaiYu液体处理工作站",
-            "children": [
-                "module_1_8tubes",
-                "module_2_96well_deep", 
-                "module_3_beaker",
-                "module_4_96well_tips"
-            ],
-            "parent": null,
-            "type": "device",
-            "class": "laiyu_liquid",
-            "position": {
-                "x": 500,
-                "y": 200,
-                "z": 0
-            },
-            "config": {
-                "total_modules": 4,
-                "total_wells": 201,
-                "safety_margin": {
-                    "x": 5.0,
-                    "y": 5.0,
-                    "z": 5.0
-                },
-                "protocol_type": ["LiquidHandlingProtocol", "PipettingProtocol", "TransferProtocol"]
-            },
-            "data": {
-                "status": "Ready",
-                "version": "1.0"
-            }
-        },
-        {
-            "id": "module_1_8tubes",
-            "name": "8管位置模块",
-            "children": [],
-            "parent": "laiyu_liquid_station",
-            "type": "container",
-            "class": "opentrons_24_tuberack_nest_1point5ml_snapcap",
-            "position": {
-                "x": 100,
-                "y": 100,
-                "z": 0
-            },
-            "config": {
-                "module_type": "tube_rack",
-                "wells_count": 8,
-                "well_diameter": 29.0,
-                "well_depth": 117.0,
-                "well_volume": 77000.0,
-                "well_shape": "circular",
-                "layout": "2x4"
-            },
-            "data": {
-                "max_volume": 77000.0,
-                "current_volume": 0.0,
-                "wells": ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
-            }
-        },
-        {
-            "id": "module_2_96well_deep",
-            "name": "96深孔板",
-            "children": [],
-            "parent": "laiyu_liquid_station",
-            "type": "plate",
-            "class": "nest_96_wellplate_2ml_deep",
-            "position": {
-                "x": 300,
-                "y": 100,
-                "z": 0
-            },
-            "config": {
-                "module_type": "96_well_deep_plate",
-                "wells_count": 96,
-                "well_diameter": 8.2,
-                "well_depth": 39.4,
-                "well_volume": 2080.0,
-                "well_shape": "circular",
-                "layout": "8x12"
-            },
-            "data": {
-                "max_volume": 2080.0,
-                "current_volume": 0.0,
-                "plate_type": "deep_well"
-            }
-        },
-        {
-            "id": "module_3_beaker",
-            "name": "敞口玻璃瓶",
-            "children": [],
-            "parent": "laiyu_liquid_station",
-            "type": "container",
-            "class": "container",
-            "position": {
-                "x": 500,
-                "y": 100,
-                "z": 0
-            },
-            "config": {
-                "module_type": "beaker_holder",
-                "wells_count": 1,
-                "well_diameter": 85.0,
-                "well_depth": 120.0,
-                "well_volume": 500000.0,
-                "well_shape": "circular",
-                "supported_containers": ["250ml", "500ml", "1000ml"]
-            },
-            "data": {
-                "max_volume": 500000.0,
-                "current_volume": 0.0,
-                "container_type": "beaker",
-                "wells": ["A1"]
-            }
-        },
-        {
-            "id": "module_4_96well_tips",
-            "name": "96吸头架",
-            "children": [],
-            "parent": "laiyu_liquid_station",
-            "type": "container",
-            "class": "tip_rack",
-            "position": {
-                "x": 700,
-                "y": 100,
-                "z": 0
-            },
-            "config": {
-                "module_type": "tip_rack",
-                "wells_count": 96,
-                "well_diameter": 8.2,
-                "well_depth": 60.0,
-                "well_volume": 6000.0,
-                "well_shape": "circular",
-                "layout": "8x12",
-                "tip_type": "standard"
-            },
-            "data": {
-                "max_volume": 6000.0,
-                "current_volume": 0.0,
-                "tip_capacity": "1000μL",
-                "tips_available": 96
-            }
-        }
-    ],
-    "links": []
-}

test/experiments/prcxi_9300.json

@@ -21,7 +21,7 @@
                 "timeout": 10.0,
                 "axis": "Left",
                 "channel_num": 8,
-                "setup": false,
+                "setup": true,
                 "debug": true,
                 "simulator": true,
                 "matrix_id": "71593"

test/experiments/reaction_station_bioyond.json

@@ -1,69 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "reaction_station_bioyond",
-            "name": "reaction_station_bioyond",
-            "parent": null,
-            "children": [
-                "Bioyond_Deck"
-            ],
-            "type": "device",
-            "class": "reaction_station.bioyond",
-            "config": {
-                "bioyond_config": {
-                    "api_key": "DE9BDDA0",
-                    "api_host": "http://192.168.1.200:44402",
-                    "workflow_mappings": {
-                        "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
-                        "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
-                        "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
-                        "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
-                        "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding(titration)": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
-                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
-                    },
-                    "material_type_mappings": {
-                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
-                    }
-                },
-                "deck": {
-                    "data": {
-                        "_resource_child_name": "Bioyond_Deck",
-                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
-                    }
-                },
-                "protocol_type": []
-            },
-            "data": {}
-        },
-        {
-            "id": "Bioyond_Deck",
-            "name": "Bioyond_Deck",
-            "sample_id": null,
-            "children": [
-            ],
-            "parent": "reaction_station_bioyond",
-            "type": "deck",
-            "class": "BIOYOND_PolymerReactionStation_Deck",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "config": {
-                "type": "BIOYOND_PolymerReactionStation_Deck",
-                "setup": true,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                }
-            },
-            "data": {}
-        }
-    ]
-}

test/experiments/reaction_station_bioyond_test.json

@@ -1,69 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "reaction_station_bioyond",
-            "name": "reaction_station_bioyond",
-            "parent": null,
-            "children": [
-                "Bioyond_Deck"
-            ],
-            "type": "device",
-            "class": "workstation.bioyond",
-            "config": {
-                "bioyond_config": {
-                    "api_key": "DE9BDDA0",
-                    "api_host": "http://192.168.1.200:44388",
-                    "workflow_mappings": {
-                        "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
-                        "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
-                        "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
-                        "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
-                        "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding(titration)": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
-                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
-                    },
-                    "material_type_mappings": {
-                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
-                    }
-                },
-                "deck": {
-                    "data": {
-                        "_resource_child_name": "Bioyond_Deck",
-                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
-                    }
-                },
-                "protocol_type": []
-            },
-            "data": {}
-        },
-        {
-            "id": "Bioyond_Deck",
-            "name": "Bioyond_Deck",
-            "sample_id": null,
-            "children": [
-            ],
-            "parent": "reaction_station_bioyond",
-            "type": "deck",
-            "class": "BIOYOND_PolymerReactionStation_Deck",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "config": {
-                "type": "BIOYOND_PolymerReactionStation_Deck",
-                "setup": true,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                }
-            },
-            "data": {}
-        }
-    ]
-}

test/experiments/test_laiyu.json

@@ -1,394 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "liquid_handler",
-            "name": "liquid_handler",
-            "parent": null,
-            "type": "device",
-            "class": "liquid_handler",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "data": {},
-            "children": [
-                "deck"
-            ],
-            "config": {
-                "deck": {
-                    "_resource_child_name": "deck",
-                    "_resource_type": "pylabrobot.resources.opentrons.deck:OTDeck",
-                    "name": "deck"
-                },
-                "backend": {
-                    "type": "UniLiquidHandlerRvizBackend"
-                    
-                },
-                "simulator": true,
-                "total_height": 300
-            }
-        },
-        {
-            "id": "deck",
-            "name": "deck",
-            "sample_id": null,
-            "children": [
-                "tip_rack",
-                "plate_well",
-                "tube_rack",
-                "bottle_rack"
-            ],
-            "parent": "liquid_handler",
-            "type": "deck",
-            "class": "TransformXYZDeck",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 18
-            },
-            "config": {
-                "type": "TransformXYZDeck",
-                "size_x": 624.3,
-                "size_y": 565.2,
-                "size_z": 900,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                }
-            },
-            "data": {}
-        },
-        {
-            "id": "tip_rack",
-            "name": "tip_rack",
-            "sample_id": null,
-            "children": [
-                "tip_rack_A1"
-            ],
-            "parent": "deck",
-            "type": "tip_rack",
-            "class": "tiprack_box",
-            "position": {
-                "x": 150,
-                "y": 7,
-                "z": 103
-            },
-            "config": {
-                "type": "TipRack",
-                "size_x": 134,
-                "size_y": 96,
-                "size_z": 7.0,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "tip_rack",
-                "model": "tiprack_box",
-                "ordering": [
-                    "A1"
-                ]
-            },
-            "data": {}
-        },
-
-
-
-
-        {
-            "id": "tip_rack_A1",
-            "name": "tip_rack_A1",
-            "sample_id": null,
-            "children": [],
-            "parent": "tip_rack",
-            "type": "container",
-            "class": "",
-            "position": {
-                "x": 11.12,
-                "y": 75,
-                "z": -91.54
-            },
-            "config": {
-                "type": "TipSpot",
-                "size_x": 9,
-                "size_y": 9,
-                "size_z": 95,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "tip_spot",
-                "model": null,
-                "prototype_tip": {
-                    "type": "Tip",
-                    "total_tip_length": 95,
-                    "has_filter": false,
-                    "maximal_volume": 1000.0,
-                    "fitting_depth": 3.29
-                }
-            },
-            "data": {
-                "tip": null,
-                "tip_state": null,
-                "pending_tip": null
-            }
-        },
-
-
-        {
-            "id": "plate_well",
-            "name": "plate_well",
-            "sample_id": null,
-            "children": [
-                "plate_well_A1"
-            ],
-            "parent": "deck",
-            "type": "plate",
-            "class": "plate_96",
-            "position": {
-                "x": 161,
-                "y": 116,
-                "z": 48.5
-            },
-            "pose": {
-                "position_3d": {
-                    "x": 161,
-                    "y": 116,
-                    "z": 48.5
-                },
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0
-                }
-            },
-            "config": {
-                "type": "Plate",
-                "size_x": 127.76,
-                "size_y": 85.48,
-                "size_z": 45.5,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "plate",
-                "model": "plate_96",
-                "ordering": [
-                    "A1"
-                ]
-            },
-            "data": {}
-        },
-
-
-
-
-
-        {
-            "id": "plate_well_A1",
-            "name": "plate_well_A1",
-            "sample_id": null,
-            "children": [],
-            "parent": "plate_well",
-            "type": "device",
-            "class": "",
-            "position": {
-                "x": 10.1,
-                "y": 70,
-                "z": 6.1
-            },
-            "config": {
-                "type": "Well",
-                "size_x": 8.2,
-                "size_y": 8.2,
-                "size_z": 38,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "well",
-                "model": null,
-                "max_volume": 2000,
-                "material_z_thickness": null,
-                "compute_volume_from_height": null,
-                "compute_height_from_volume": null,
-                "bottom_type": "unknown",
-                "cross_section_type": "rectangle"
-            },
-            "data": {
-                "liquids": [["water", 50.0]],
-                "pending_liquids": [["water", 50.0]],
-                "liquid_history": []
-            }
-        },
-
-
-        {
-            "id": "tube_rack",
-            "name": "tube_rack",
-            "sample_id": null,
-            "children": [
-                "tube_rack_A1"
-            ],
-            "parent": "deck",
-            "type": "container",
-            "class": "tube_container",
-            "position": {
-                "x": 0,
-                "y": 127,
-                "z": 0
-            },
-            "config": {
-                "type": "Plate",
-                "size_x": 151,
-                "size_y": 75,
-                "size_z": 75,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "model": "tube_container",
-                "ordering": [
-                    "A1"
-                ]
-            },
-            "data": {}
-        },
-
-
-        {
-            "id": "tube_rack_A1",
-            "name": "tube_rack_A1",
-            "sample_id": null,
-            "children": [],
-            "parent": "tube_rack",
-            "type": "device",
-            "class": "",
-            "position": {
-                "x": 6,
-                "y": 38,
-                "z": 10
-            },
-            "config": {
-                "type": "Well",
-                "size_x": 34,
-                "size_y": 34,
-                "size_z": 117,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "tube",
-                "model": null,
-                "max_volume": 2000,
-                "material_z_thickness": null,
-                "compute_volume_from_height": null,
-                "compute_height_from_volume": null,
-                "bottom_type": "unknown",
-                "cross_section_type": "rectangle"
-            },
-            "data": {
-                "liquids": [["water", 50.0]],
-                "pending_liquids": [["water", 50.0]],
-                "liquid_history": []
-            }
-        }
-
-
-        ,
-
-
-        {
-            "id": "bottle_rack",
-            "name": "bottle_rack",
-            "sample_id": null,
-            "children": [
-                "bottle_rack_A1"
-            ],
-            "parent": "deck",
-            "type": "container",
-            "class": "bottle_container",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "config": {
-                "type": "Plate",
-                "size_x": 130,
-                "size_y": 117,
-                "size_z": 8,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "tube_rack",
-                "model": "bottle_container",
-                "ordering": [
-                    "A1"
-                ]
-            },
-            "data": {}
-        },
-
-
-        {
-            "id": "bottle_rack_A1",
-            "name": "bottle_rack_A1",
-            "sample_id": null,
-            "children": [],
-            "parent": "bottle_rack",
-            "type": "device",
-            "class": "",
-            "position": {
-                "x": 25,
-                "y": 18.5,
-                "z": 8
-            },
-            "config": {
-                "type": "Well",
-                "size_x": 80,
-                "size_y": 80,
-                "size_z": 117,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                },
-                "category": "tube",
-                "model": null,
-                "max_volume": 2000,
-                "material_z_thickness": null,
-                "compute_volume_from_height": null,
-                "compute_height_from_volume": null,
-                "bottom_type": "unknown",
-                "cross_section_type": "rectangle"
-            },
-            "data": {
-                "liquids": [["water", 50.0]],
-                "pending_liquids": [["water", 50.0]],
-                "liquid_history": []
-            }
-        }
-
-
-    ],
-    "links": []
-}

test/resources/bioyond_materials_liquidhandling_1.json

@@ -1,181 +0,0 @@
-[
-    {
-        "id": "3a1c62c4-c3d2-b803-b72d-7f1153ffef3b",
-        "typeName": "试剂瓶",
-        "code": "0004-00050",
-        "barCode": "",
-        "name": "NMP",
-        "quantity": 287.16699029126215,
-        "lockQuantity": 285.16699029126215,
-        "unit": "毫升",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198c-c2d0-efce-0939-69ca5a7dfd39",
-                "whid": "3a14198c-c2cc-0290-e086-44a428fba248",
-                "whName": "试剂堆栈",
-                "code": "0001-0008",
-                "x": 2,
-                "y": 4,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": []
-    },
-    {
-        "id": "3a1cdefe-0e03-1bc1-1296-dae1905c4108",
-        "typeName": "试剂瓶",
-        "code": "0004-00052",
-        "barCode": "",
-        "name": "NMP",
-        "quantity": 386.8990291262136,
-        "lockQuantity": 45.89902912621359,
-        "unit": "毫升",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198c-c2d0-f3e7-871a-e470d144296f",
-                "whid": "3a14198c-c2cc-0290-e086-44a428fba248",
-                "whName": "试剂堆栈",
-                "code": "0001-0005",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": []
-    },
-    {
-        "id": "3a1cdefe-0e03-68a4-bcb3-02fc6ba72d1b",
-        "typeName": "试剂瓶",
-        "code": "0004-00053",
-        "barCode": "",
-        "name": "NMP",
-        "quantity": 400.0,
-        "lockQuantity": 0.0,
-        "unit": "",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198c-c2d0-2070-efc8-44e245f10c6f",
-                "whid": "3a14198c-c2cc-0290-e086-44a428fba248",
-                "whName": "试剂堆栈",
-                "code": "0001-0006",
-                "x": 2,
-                "y": 2,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": []
-    },
-    {
-        "id": "3a1cdefe-d5e0-d850-5439-4499f20f07fe",
-        "typeName": "分装板",
-        "code": "0007-00185",
-        "barCode": "",
-        "name": "1010",
-        "quantity": 1.0,
-        "lockQuantity": 2.0,
-        "unit": "块",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198e-6929-46fe-841e-03dd753f1e4a",
-                "whid": "3a14198e-6928-121f-7ca6-88ad3ae7e6a0",
-                "whName": "粉末堆栈",
-                "code": "0002-0009",
-                "x": 3,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": [
-            {
-                "id": "3a1cdefe-d5e0-28a4-f5d0-f7e2436c575f",
-                "detailMaterialId": "3a1cdefe-d5e0-94ae-f770-27847e73ad38",
-                "code": null,
-                "name": "90%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 2,
-                "y": 3,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdefe-d5e0-3ed6-3607-133df89baf5b",
-                "detailMaterialId": "3a1cdefe-d5e0-f2fa-66bf-94c565d852fb",
-                "code": null,
-                "name": "10%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 1,
-                "y": 3,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdefe-d5e0-72b6-e015-be7b93cf09eb",
-                "detailMaterialId": "3a1cdefe-d5e0-81cf-7dad-2e51cab9ffd6",
-                "code": null,
-                "name": "90%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdefe-d5e0-81d3-ad30-48134afc9ce7",
-                "detailMaterialId": "3a1cdefe-d5e0-3fa1-cc72-fda6276ae38d",
-                "code": null,
-                "name": "10%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdefe-d5e0-dbdf-d966-9a8926fe1e06",
-                "detailMaterialId": "3a1cdefe-d5e0-c632-c7da-02d385b18628",
-                "code": null,
-                "name": "10%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdefe-d5e0-f099-b260-e3089a2d08c3",
-                "detailMaterialId": "3a1cdefe-d5e0-561f-73b6-f8501f814dbb",
-                "code": null,
-                "name": "90%分装小瓶",
-                "quantity": "1",
-                "lockQuantity": "1",
-                "unit": "个",
-                "x": 2,
-                "y": 2,
-                "z": 1,
-                "associateId": null
-            }
-        ]
-    }
-]

test/resources/bioyond_materials_liquidhandling_2.json

@@ -1,216 +0,0 @@
-[
-    {
-        "id": "3a1cde21-a4f4-4f95-6221-eaafc2ae6a8d",
-        "typeName": "样品瓶",
-        "code": "0002-00407",
-        "barCode": "",
-        "name": "ODA",
-        "quantity": 25.0,
-        "lockQuantity": 2.0,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    },
-    {
-        "id": "3a1cde21-a4f4-7887-9258-e8f8ab7c8a7a",
-        "typeName": "样品板",
-        "code": "0008-00160",
-        "barCode": "",
-        "name": "1010sample",
-        "quantity": 1.0,
-        "lockQuantity": 27.69187,
-        "unit": "块",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198e-6929-4379-affa-9a2935c17f99",
-                "whid": "3a14198e-6928-121f-7ca6-88ad3ae7e6a0",
-                "whName": "粉末堆栈",
-                "code": "0002-0002",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": [
-            {
-                "id": "3a1cde21-a4f4-0339-f2b6-8e680ad7e8c7",
-                "detailMaterialId": "3a1cde21-a4f4-ab37-f7a2-ecc3bc083e7c",
-                "code": null,
-                "name": "MPDA",
-                "quantity": "10.505",
-                "lockQuantity": "-0.0174",
-                "unit": "克",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cde21-a4f4-a21a-23cf-bb7857b41947",
-                "detailMaterialId": "3a1cde21-a4f4-99c7-55e7-c80c7320e300",
-                "code": null,
-                "name": "ODA",
-                "quantity": "1.795",
-                "lockQuantity": "2.0093",
-                "unit": "克",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cde21-a4f4-af1b-ba0b-2874836800e9",
-                "detailMaterialId": "3a1cde21-a4f4-4f95-6221-eaafc2ae6a8d",
-                "code": null,
-                "name": "ODA",
-                "quantity": "25",
-                "lockQuantity": "2",
-                "unit": "克",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "associateId": null
-            }
-        ]
-    },
-    {
-        "id": "3a1cde21-a4f4-99c7-55e7-c80c7320e300",
-        "typeName": "样品瓶",
-        "code": "0002-00406",
-        "barCode": "",
-        "name": "ODA",
-        "quantity": 1.795,
-        "lockQuantity": 2.00927,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    },
-    {
-        "id": "3a1cde21-a4f4-ab37-f7a2-ecc3bc083e7c",
-        "typeName": "样品瓶",
-        "code": "0002-00408",
-        "barCode": "",
-        "name": "MPDA",
-        "quantity": 10.505,
-        "lockQuantity": -0.0174,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    },
-    {
-        "id": "3a1cdeff-c92a-08f6-c822-732ab734154c",
-        "typeName": "样品板",
-        "code": "0008-00161",
-        "barCode": "",
-        "name": "1010sample2",
-        "quantity": 1.0,
-        "lockQuantity": 3.0,
-        "unit": "块",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a14198e-6929-31f0-8a22-0f98f72260df",
-                "whid": "3a14198e-6928-121f-7ca6-88ad3ae7e6a0",
-                "whName": "粉末堆栈",
-                "code": "0002-0001",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": [
-            {
-                "id": "3a1cdeff-c92b-3ace-9623-0bcdef6fa07d",
-                "detailMaterialId": "3a1cdeff-c92b-d084-2a96-5d62746d9321",
-                "code": null,
-                "name": "BTDA1",
-                "quantity": "0.362",
-                "lockQuantity": "14.494",
-                "unit": "克",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdeff-c92b-856e-f481-792b91b6dbde",
-                "detailMaterialId": "3a1cdeff-c92b-30f2-f907-8f5e2fe0586b",
-                "code": null,
-                "name": "BTDA3",
-                "quantity": "1.935",
-                "lockQuantity": "13.067",
-                "unit": "克",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "associateId": null
-            },
-            {
-                "id": "3a1cdeff-c92b-d144-c5e5-ab9d94e21187",
-                "detailMaterialId": "3a1cdeff-c92b-519f-a70f-0bb71af537a7",
-                "code": null,
-                "name": "BTDA2",
-                "quantity": "1.903",
-                "lockQuantity": "13.035",
-                "unit": "克",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "associateId": null
-            }
-        ]
-    },
-    {
-        "id": "3a1cdeff-c92b-30f2-f907-8f5e2fe0586b",
-        "typeName": "样品瓶",
-        "code": "0002-00411",
-        "barCode": "",
-        "name": "BTDA3",
-        "quantity": 1.935,
-        "lockQuantity": 13.067,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    },
-    {
-        "id": "3a1cdeff-c92b-519f-a70f-0bb71af537a7",
-        "typeName": "样品瓶",
-        "code": "0002-00410",
-        "barCode": "",
-        "name": "BTDA2",
-        "quantity": 1.903,
-        "lockQuantity": 13.035,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    },
-    {
-        "id": "3a1cdeff-c92b-d084-2a96-5d62746d9321",
-        "typeName": "样品瓶",
-        "code": "0002-00409",
-        "barCode": "",
-        "name": "BTDA1",
-        "quantity": 0.362,
-        "lockQuantity": 14.494,
-        "unit": "克",
-        "status": 1,
-        "isUse": false,
-        "locations": [],
-        "detail": []
-    }
-]

test/resources/bioyond_materials_reaction.json

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

test/resources/test_bottle_carrier.py

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

test/resources/test_converter_bioyond.py

@@ -1,76 +0,0 @@
-import pytest
-import json
-import os
-
-from pylabrobot.resources import Resource as ResourcePLR
-from unilabos.resources.graphio import resource_bioyond_to_plr
-from unilabos.registry.registry import lab_registry
-
-from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
-
-lab_registry.setup()
-
-
-type_mapping = {
-    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-    "样品板": "BIOYOND_PolymerStation_6StockCarrier",
-    "分装板": "BIOYOND_PolymerStation_6VialCarrier",
-    "样品瓶": "BIOYOND_PolymerStation_Solid_Stock",
-    "90%分装小瓶": "BIOYOND_PolymerStation_Solid_Vial",
-    "10%分装小瓶": "BIOYOND_PolymerStation_Liquid_Vial",
-}
-
-type_uuid_mapping = {
-    "烧杯": "",
-    "试剂瓶": "",
-    "样品板": "",
-    "分装板": "3a14196e-5dfe-6e21-0c79-fe2036d052c4",
-    "样品瓶": "3a14196a-cf7d-8aea-48d8-b9662c7dba94",
-    "90%分装小瓶": "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea",
-    "10%分装小瓶": "3a14196c-76be-2279-4e22-7310d69aed68",
-}
-
-
-@pytest.fixture
-def bioyond_materials_reaction() -> list[dict]:
-    print("加载 BioYond 物料数据...")
-    print(os.getcwd())
-    with open("bioyond_materials_reaction.json", "r", encoding="utf-8") as f:
-        data = json.load(f)
-    print(f"加载了 {len(data)} 条物料数据")
-    return data
-
-
-@pytest.fixture
-def bioyond_materials_liquidhandling_1() -> list[dict]:
-    print("加载 BioYond 物料数据...")
-    print(os.getcwd())
-    with open("bioyond_materials_liquidhandling_1.json", "r", encoding="utf-8") as f:
-        data = json.load(f)
-    print(f"加载了 {len(data)} 条物料数据")
-    return data
-
-
-@pytest.fixture
-def bioyond_materials_liquidhandling_2() -> list[dict]:
-    print("加载 BioYond 物料数据...")
-    print(os.getcwd())
-    with open("bioyond_materials_liquidhandling_2.json", "r", encoding="utf-8") as f:
-        data = json.load(f)
-    print(f"加载了 {len(data)} 条物料数据")
-    return data
-
-
-@pytest.mark.parametrize("materials_fixture", [
-    "bioyond_materials_reaction",
-    "bioyond_materials_liquidhandling_1",
-])
-def test_bioyond_to_plr(materials_fixture, request) -> list[dict]:
-    materials = request.getfixturevalue(materials_fixture)
-    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
-    output = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=deck)
-    print(deck.summary())
-    print([resource.serialize() for resource in output])
-    print([resource.serialize_all_state() for resource in output])
-    json.dump(deck.serialize(), open("test.json", "w", encoding="utf-8"), indent=4)

unilabos-linux-64.yaml

@@ -63,9 +63,6 @@ dependencies:
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
   - uni-lab::ros-humble-unilabos-msgs
-  - zeep
-  - jinja2
-  - pprp
   - pip:
       - paho-mqtt
       - opentrons_shared_data

unilabos-osx-64.yaml

@@ -62,9 +62,6 @@ dependencies:
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
   - uni-lab::ros-humble-unilabos-msgs
-  - zeep
-  - jinja2
-  - pprp
   - pip:
       - paho-mqtt
       - opentrons_shared_data

unilabos-osx-arm64.yaml

@@ -64,9 +64,6 @@ dependencies:
   # ros-humble-gazebo-ros // ignored because of the conflict with ign-gazebo
   # ilab equipments
   - uni-lab::ros-humble-unilabos-msgs
-  - zeep
-  - jinja2
-  - pprp
   - pip:
       - paho-mqtt
       - opentrons_shared_data

unilabos-win64.yaml

@@ -65,9 +65,6 @@ dependencies:
   - uni-lab::ros-humble-unilabos-msgs
   # driver
   #- crcmod
-  - zeep
-  - jinja2
-  - pprp
   - pip:
       - paho-mqtt
       - opentrons_shared_data

unilabos/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.10.7"

unilabos/app/backend.py

@@ -1,15 +1,14 @@
 import threading
 
-from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.utils import logger
 
 
 # 根据选择的 backend 启动相应的功能
 def start_backend(
     backend: str,
-    devices_config: ResourceTreeSet,
-    resources_config: ResourceTreeSet,
-    resources_edge_config: list[dict] = [],
+    devices_config: dict = {},
+    resources_config: list = [],
+    resources_edge_config: list = [],
     graph=None,
     controllers_config: dict = {},
     bridges=[],

unilabos/app/main.py

@@ -6,12 +6,10 @@ import signal
 import sys
 import threading
 import time
-from typing import Dict, Any, List
+from copy import deepcopy
 
-import networkx as nx
 import yaml
 
-from unilabos.ros.nodes.resource_tracker import ResourceTreeSet, ResourceDict
 
 # 首先添加项目根目录到路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -45,7 +43,7 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
     for i, arg in enumerate(sys.argv):
         for option_string in option_strings:
             if arg.startswith(option_string):
-                new_arg = arg[:2] + arg[2:len(option_string)].replace("-", "_") + arg[len(option_string):]
+                new_arg = arg[:2] + arg[2 : len(option_string)].replace("-", "_") + arg[len(option_string) :]
                 sys.argv[i] = new_arg
                 break
 
@@ -210,6 +208,7 @@ def main():
                 os.path.join(os.path.dirname(os.path.dirname(__file__)), "config", "example_config.py"), config_path
             )
             print_status(f"已创建 local_config.py 路径： {config_path}", "info")
+            os._exit(1)
         else:
             os._exit(1)
     # 加载配置文件
@@ -227,15 +226,6 @@ def main():
     else:
         HTTPConfig.remote_addr = args_dict.get("addr", "")
 
-    # 设置BasicConfig参数
-    if args_dict.get("ak", ""):
-        BasicConfig.ak = args_dict.get("ak", "")
-        print_status("传入了ak参数，优先采用传入参数！", "info")
-    if args_dict.get("sk", ""):
-        BasicConfig.sk = args_dict.get("sk", "")
-        print_status("传入了sk参数，优先采用传入参数！", "info")
-
-    # 使用远程资源启动
     if args_dict["use_remote_resource"]:
         print_status("使用远程资源启动", "info")
         from unilabos.app.web import http_client
@@ -247,6 +237,13 @@ def main():
         else:
             print_status("远程资源不存在，本地将进行首次上报！", "info")
 
+    # 设置BasicConfig参数
+    if args_dict.get("ak", ""):
+        BasicConfig.ak = args_dict.get("ak", "")
+        print_status("传入了ak参数，优先采用传入参数！", "info")
+    if args_dict.get("sk", ""):
+        BasicConfig.sk = args_dict.get("sk", "")
+        print_status("传入了sk参数，优先采用传入参数！", "info")
     BasicConfig.working_dir = working_dir
     BasicConfig.is_host_mode = not args_dict.get("is_slave", False)
     BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
@@ -261,6 +258,8 @@ def main():
         read_node_link_json,
         read_graphml,
         dict_from_graph,
+        dict_to_nested_dict,
+        initialize_resources,
     )
     from unilabos.app.communication import get_communication_client
     from unilabos.registry.registry import build_registry
@@ -280,11 +279,8 @@ def main():
     if not BasicConfig.ak or not BasicConfig.sk:
         print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
         os._exit(1)
-    graph: nx.Graph
-    resource_tree_set: ResourceTreeSet
-    resource_links: List[Dict[str, Any]]
-    request_startup_json = http_client.request_startup_json()
     if args_dict["graph"] is None:
+        request_startup_json = http_client.request_startup_json()
         if not request_startup_json:
             print_status(
                 "未指定设备加载文件路径，尝试从HTTP获取失败，请检查网络或者使用-g参数指定设备加载文件路径", "error"
@@ -292,61 +288,58 @@ def main():
             os._exit(1)
         else:
             print_status("联网获取设备加载文件成功", "info")
-        graph, resource_tree_set, resource_links = read_node_link_json(request_startup_json)
+        graph, data = read_node_link_json(request_startup_json)
     else:
         file_path = args_dict["graph"]
         if file_path.endswith(".json"):
-            graph, resource_tree_set, resource_links = read_node_link_json(file_path)
+            graph, data = read_node_link_json(file_path)
         else:
-            graph, resource_tree_set, resource_links = read_graphml(file_path)
+            graph, data = read_graphml(file_path)
     import unilabos.resources.graphio as graph_res
 
     graph_res.physical_setup_graph = graph
-    resource_edge_info = modify_to_backend_format(resource_links)
+    resource_edge_info = modify_to_backend_format(data["links"])
     materials = lab_registry.obtain_registry_resource_info()
     materials.extend(lab_registry.obtain_registry_device_info())
     materials = {k["id"]: k for k in materials}
-    # 从 ResourceTreeSet 中获取节点信息
-    nodes = {node.res_content.id: node.res_content for node in resource_tree_set.all_nodes}
+    nodes = {k["id"]: k for k in data["nodes"]}
     edge_info = len(resource_edge_info)
     for ind, i in enumerate(resource_edge_info[::-1]):
-        source_node: ResourceDict = nodes[i["source"]]
-        target_node: ResourceDict = nodes[i["target"]]
+        source_node = nodes[i["source"]]
+        target_node = nodes[i["target"]]
         source_handle = i["sourceHandle"]
         target_handle = i["targetHandle"]
         source_handler_keys = [
-            h["handler_key"] for h in materials[source_node.klass]["handles"] if h["io_type"] == "source"
+            h["handler_key"] for h in materials[source_node["class"]]["handles"] if h["io_type"] == "source"
         ]
         target_handler_keys = [
-            h["handler_key"] for h in materials[target_node.klass]["handles"] if h["io_type"] == "target"
+            h["handler_key"] for h in materials[target_node["class"]]["handles"] if h["io_type"] == "target"
         ]
         if source_handle not in source_handler_keys:
             print_status(
-                f"节点 {source_node.id} 的source端点 {source_handle} 不存在，请检查，支持的端点 {source_handler_keys}",
+                f"节点 {source_node['id']} 的source端点 {source_handle} 不存在，请检查，支持的端点 {source_handler_keys}",
                 "error",
             )
             resource_edge_info.pop(edge_info - ind - 1)
             continue
         if target_handle not in target_handler_keys:
             print_status(
-                f"节点 {target_node.id} 的target端点 {target_handle} 不存在，请检查，支持的端点 {target_handler_keys}",
+                f"节点 {target_node['id']} 的target端点 {target_handle} 不存在，请检查，支持的端点 {target_handler_keys}",
                 "error",
             )
             resource_edge_info.pop(edge_info - ind - 1)
             continue
 
-    # 如果从远端获取了物料信息，则与本地物料进行同步
-    if request_startup_json and "nodes" in request_startup_json:
-        print_status("开始同步远端物料到本地...", "info")
-        remote_tree_set = ResourceTreeSet.from_raw_list(request_startup_json["nodes"])
-        resource_tree_set.merge_remote_resources(remote_tree_set)
-        print_status("远端物料同步完成", "info")
-
-    # 使用 ResourceTreeSet 代替 list
-    args_dict["resources_config"] = resource_tree_set
-    args_dict["devices_config"] = resource_tree_set
+    devices_and_resources = dict_from_graph(graph_res.physical_setup_graph)
+    # args_dict["resources_config"] = initialize_resources(list(deepcopy(devices_and_resources).values()))
+    args_dict["resources_config"] = list(devices_and_resources.values())
+    args_dict["devices_config"] = dict_to_nested_dict(deepcopy(devices_and_resources), devices_only=False)
     args_dict["graph"] = graph_res.physical_setup_graph
 
+    print_status(f"{len(args_dict['resources_config'])} Resources loaded:", "info")
+    for i in args_dict["resources_config"]:
+        print_status(f"DeviceId: {i['id']}, Class: {i['class']}", "info")
+
     if BasicConfig.upload_registry:
         # 设备注册到服务端 - 需要 ak 和 sk
         if args_dict.get("ak") and args_dict.get("sk"):
@@ -359,7 +352,9 @@ def main():
         else:
             print_status("未提供 ak 和 sk，跳过设备注册", "info")
     else:
-        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
+        print_status(
+            "本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning"
+        )
 
     if args_dict["controllers"] is not None:
         args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
@@ -389,16 +384,13 @@ def main():
     # web visiualize 2D
     if args_dict["visual"] != "disable":
         enable_rviz = args_dict["visual"] == "rviz"
-        devices_and_resources = dict_from_graph(graph_res.physical_setup_graph)
         if devices_and_resources is not None:
             from unilabos.device_mesh.resource_visalization import (
                 ResourceVisualization,
             )  # 此处开启后，logger会变更为INFO，有需要请调整
 
             resource_visualization = ResourceVisualization(
-                devices_and_resources,
-                [n.res_content for n in args_dict["resources_config"].all_nodes],  # type: ignore  # FIXME
-                enable_rviz=enable_rviz,
+                devices_and_resources, args_dict["resources_config"], enable_rviz=enable_rviz
             )
             args_dict["resources_mesh_config"] = resource_visualization.resource_model
             start_backend(**args_dict)

unilabos/app/register.py

@@ -1,6 +1,11 @@
+import argparse
 import json
 import time
 
+from unilabos.config.config import BasicConfig
+from unilabos.registry.registry import build_registry
+
+from unilabos.app.main import load_config_from_file
 from unilabos.utils.log import logger
 from unilabos.utils.type_check import TypeEncoder
 

unilabos/app/web/client.py

@@ -9,7 +9,6 @@ import os
 from typing import List, Dict, Any, Optional
 
 import requests
-from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.utils.log import info
 from unilabos.config.config import HTTPConfig, BasicConfig
 from unilabos.utils import logger
@@ -26,7 +25,6 @@ class HTTPClient:
             remote_addr: 远程服务器地址，如果不提供则从配置中获取
             auth: 授权信息
         """
-        self.initialized = False
         self.remote_addr = remote_addr or HTTPConfig.remote_addr
         if auth is not None:
             self.auth = auth
@@ -36,7 +34,7 @@ class HTTPClient:
             info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
         info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")
 
-    def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
+    def resource_edge_add(self, resources: List[Dict[str, Any]], database_process_later: bool) -> requests.Response:
         """
         添加资源
 
@@ -47,7 +45,7 @@ class HTTPClient:
             Response: API响应对象
         """
         response = requests.post(
-            f"{self.remote_addr}/edge/material/edge",
+            f"{self.remote_addr}/lab/material/edge",
             json={
                 "edges": resources,
             },
@@ -62,108 +60,22 @@ class HTTPClient:
             logger.error(f"添加物料关系失败: {response.status_code}, {response.text}")
         return response
 
-    def resource_tree_add(self, resources: ResourceTreeSet, mount_uuid: str, first_add: bool) -> Dict[str, str]:
-        """
-        添加资源
-
-        Args:
-            resources: 要添加的资源树集合（ResourceTreeSet）
-            mount_uuid: 要挂载的资源的uuid
-            first_add: 是否为首次添加资源，可以是host也可以是slave来的
-        Returns:
-            Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
-        """
-        # 从序列化数据中提取所有节点的UUID（保存旧UUID）
-        old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
-        if not self.initialized or first_add:
-            self.initialized = True
-            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
-                f"{self.remote_addr}/edge/material",
-                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
-        else:
-            response = requests.put(
-                f"{self.remote_addr}/edge/material",
-                json={"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
-
-        # 处理响应，构建UUID映射
-        uuid_mapping = {}
-        if response.status_code == 200:
-            res = response.json()
-            if "code" in res and res["code"] != 0:
-                logger.error(f"添加物料失败: {response.text}")
-            else:
-                data = res["data"]
-                for i in data:
-                    uuid_mapping[i["uuid"]] = i["cloud_uuid"]
-        else:
-            logger.error(f"添加物料失败: {response.text}")
-        for u, n in old_uuids.items():
-            if u in uuid_mapping:
-                n.res_content.uuid = uuid_mapping[u]
-                for c in n.children:
-                    c.res_content.parent_uuid = n.res_content.uuid
-            else:
-                logger.warning(f"资源UUID未更新: {u}")
-        return uuid_mapping
-
-    def resource_tree_get(self, uuid_list: List[str], with_children: bool) -> List[Dict[str, Any]]:
-        """
-        添加资源
-
-        Args:
-            uuid_list: List[str]
-        Returns:
-            Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
-        """
-        response = requests.post(
-            f"{self.remote_addr}/edge/material/query",
-            json={"uuids": uuid_list, "with_children": with_children},
-            headers={"Authorization": f"Lab {self.auth}"},
-            timeout=100,
-        )
-        if response.status_code == 200:
-            res = response.json()
-            if "code" in res and res["code"] != 0:
-                logger.error(f"查询物料失败: {response.text}")
-            else:
-                data = res["data"]["nodes"]
-                return data
-        else:
-            logger.error(f"查询物料失败: {response.text}")
-        return []
-
-    def resource_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
+    def resource_add(self, resources: List[Dict[str, Any]], database_process_later: bool) -> requests.Response:
         """
         添加资源
 
         Args:
             resources: 要添加的资源列表
+            database_process_later: 后台处理资源
         Returns:
             Response: API响应对象
         """
-        if not self.initialized:
-            self.initialized = True
-            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
-                f"{self.remote_addr}/lab/material",
-                json={"nodes": resources},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
-        else:
-            response = requests.put(
-                f"{self.remote_addr}/lab/material",
-                json={"nodes": resources},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
+        response = requests.post(
+            f"{self.remote_addr}/lab/material",
+            json={"nodes": resources},
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=100,
+        )
         if response.status_code == 200:
             res = response.json()
             if "code" in res and res["code"] != 0:
@@ -219,29 +131,13 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        if not self.initialized:
-            self.initialized = True
-            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
-            response = requests.post(
-                f"{self.remote_addr}/lab/material",
-                json={"nodes": resources},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
-        else:
-            response = requests.put(
-                f"{self.remote_addr}/lab/material",
-                json={"nodes": resources},
-                headers={"Authorization": f"Lab {self.auth}"},
-                timeout=100,
-            )
-        if response.status_code == 200:
-            res = response.json()
-            if "code" in res and res["code"] != 0:
-                logger.error(f"添加物料失败: {response.text}")
-        if response.status_code != 200:
-            logger.error(f"添加物料失败: {response.text}")
-        return response.json()
+        response = requests.patch(
+            f"{self.remote_addr}/lab/resource/batch_update/?edge_format=1",
+            json=resources,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=100,
+        )
+        return response
 
     def upload_file(self, file_path: str, scene: str = "models") -> requests.Response:
         """
@@ -298,7 +194,7 @@ class HTTPClient:
             Response: API响应对象
         """
         response = requests.get(
-            f"{self.remote_addr}/edge/material/download",
+            f"{self.remote_addr}/lab/resource/graph_info/",
             headers={"Authorization": f"Lab {self.auth}"},
             timeout=(3, 30),
         )

unilabos/compile/add_protocol.py

@@ -155,7 +155,7 @@ def generate_add_protocol(
                             "device_id": stirrer_id,
                             "action_name": "start_stir",
                             "action_kwargs": {
-                                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                                "vessel": vessel_id,  # 🔧 使用 vessel_id
                                 "stir_speed": stir_speed,
                                 "purpose": f"准备添加固体 {reagent}"
                             }
@@ -169,7 +169,7 @@ def generate_add_protocol(
                 
                 # 固体加样
                 add_kwargs = {
-                    "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                    "vessel": vessel_id,  # 🔧 使用 vessel_id
                     "reagent": reagent,
                     "purpose": purpose,
                     "event": event,
@@ -232,7 +232,7 @@ def generate_add_protocol(
                         "device_id": stirrer_id,
                         "action_name": "start_stir",
                         "action_kwargs": {
-                            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                            "vessel": vessel_id,  # 🔧 使用 vessel_id
                             "stir_speed": stir_speed,
                             "purpose": f"准备添加液体 {reagent}"
                         }

unilabos/compile/adjustph_protocol.py

@@ -325,7 +325,7 @@ def generate_adjust_ph_protocol(
                     "device_id": stirrer_id,
                     "action_name": "start_stir",
                     "action_kwargs": {
-                        "vessel": {"id": vessel_id},
+                        "vessel": vessel_id,
                         "stir_speed": stir_speed,
                         "purpose": f"pH调节: 启动搅拌，准备添加 {reagent}"
                     }

unilabos/compile/centrifuge_protocol.py

@@ -156,7 +156,7 @@ def generate_centrifuge_protocol(
         "device_id": centrifuge_id,
         "action_name": "centrifuge",
         "action_kwargs": {
-            "vessel": {"id": centrifuge_vessel},
+            "vessel": centrifuge_vessel,
             "speed": speed,
             "time": time,
             "temp": temp

unilabos/compile/clean_vessel_protocol.py

@@ -143,7 +143,7 @@ def generate_clean_vessel_protocol(
             "device_id": heatchill_id,
             "action_name": "heat_chill_start",
             "action_kwargs": {
-                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                 "temp": temp,
                 "purpose": f"cleaning with {solvent}"
             }
@@ -295,7 +295,7 @@ def generate_clean_vessel_protocol(
             "device_id": heatchill_id,
             "action_name": "heat_chill_stop",
             "action_kwargs": {
-                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "vessel": vessel_id  # 🔧 使用 vessel_id
             }
         }
         action_sequence.append(heatchill_stop_action)

unilabos/compile/dissolve_protocol.py

@@ -563,7 +563,7 @@ def generate_dissolve_protocol(
                     "device_id": heatchill_id,
                     "action_name": "heat_chill_start",
                     "action_kwargs": {
-                        "vessel": {"id": vessel_id},
+                        "vessel": vessel_id,
                         "temp": final_temp,
                         "purpose": f"溶解准备 - {event}" if event else "溶解准备"
                     }
@@ -587,7 +587,7 @@ def generate_dissolve_protocol(
                     "device_id": stirrer_id,
                     "action_name": "start_stir",
                     "action_kwargs": {
-                        "vessel": {"id": vessel_id},
+                        "vessel": vessel_id,
                         "stir_speed": stir_speed,
                         "purpose": f"溶解搅拌 - {event}" if event else "溶解搅拌"
                     }
@@ -612,7 +612,7 @@ def generate_dissolve_protocol(
                 
                 # 固体加样
                 add_kwargs = {
-                    "vessel": {"id": vessel_id},
+                    "vessel": vessel_id,
                     "reagent": reagent or amount or "solid reagent",
                     "purpose": f"溶解固体试剂 - {event}" if event else "溶解固体试剂",
                     "event": event
@@ -758,7 +758,7 @@ def generate_dissolve_protocol(
                     "device_id": heatchill_id,
                     "action_name": "heat_chill",
                     "action_kwargs": {
-                        "vessel": {"id": vessel_id},
+                        "vessel": vessel_id,
                         "temp": final_temp,
                         "time": final_time,
                         "stir": True,
@@ -776,7 +776,7 @@ def generate_dissolve_protocol(
                     "device_id": stirrer_id,
                     "action_name": "stir",
                     "action_kwargs": {
-                        "vessel": {"id": vessel_id},
+                        "vessel": vessel_id,
                         "stir_time": final_time,
                         "stir_speed": stir_speed,
                         "settling_time": 0,
@@ -802,7 +802,7 @@ def generate_dissolve_protocol(
                 "device_id": heatchill_id,
                 "action_name": "heat_chill_stop",
                 "action_kwargs": {
-                    "vessel": {"id": vessel_id},
+                    "vessel": vessel_id
                 }
             }
             action_sequence.append(stop_action)

unilabos/compile/dry_protocol.py

@@ -167,7 +167,7 @@ def generate_dry_protocol(
         "device_id": heater_id,
         "action_name": "heat_chill_start",
         "action_kwargs": {
-            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "vessel": vessel_id,  # 🔧 使用 vessel_id
             "temp": dry_temp,
             "purpose": f"干燥 {compound or '化合物'}"
         }
@@ -191,7 +191,7 @@ def generate_dry_protocol(
         "device_id": heater_id,
         "action_name": "heat_chill",
         "action_kwargs": {
-            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "vessel": vessel_id,  # 🔧 使用 vessel_id
             "temp": dry_temp,
             "time": simulation_time,
             "purpose": f"干燥 {compound or '化合物'}，保持温度 {dry_temp}°C"
@@ -251,7 +251,7 @@ def generate_dry_protocol(
         "device_id": heater_id,
         "action_name": "heat_chill_stop",
         "action_kwargs": {
-            "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+            "vessel": vessel_id,  # 🔧 使用 vessel_id
             "purpose": f"干燥完成，停止加热"
         }
     })

unilabos/compile/evacuateandrefill_protocol.py

@@ -452,7 +452,7 @@ def generate_evacuateandrefill_protocol(
             "device_id": stirrer_id,
             "action_name": "start_stir",
             "action_kwargs": {
-                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                 "stir_speed": STIR_SPEED,
                 "purpose": "抽真空充气前预搅拌"
             }
@@ -685,7 +685,7 @@ def generate_evacuateandrefill_protocol(
         action_sequence.append({
             "device_id": stirrer_id,
             "action_name": "stop_stir",
-            "action_kwargs": {"vessel": {"id": vessel_id},}  # 🔧 使用 vessel_id
+            "action_kwargs": {"vessel": vessel_id}  # 🔧 使用 vessel_id
         })
     else:
         action_sequence.append(create_action_log("跳过搅拌器停止", "⏭️"))

unilabos/compile/evaporate_protocol.py

@@ -329,7 +329,7 @@ def generate_evaporate_protocol(
         "device_id": rotavap_device,
         "action_name": "evaporate",
         "action_kwargs": {
-            "vessel": {"id": target_vessel},
+            "vessel": target_vessel,
             "pressure": float(pressure),
             "temp": float(temp),
             "time": float(final_time),  # 🔧 强制转换为float类型

unilabos/compile/heatchill_protocol.py

@@ -220,7 +220,7 @@ def generate_heat_chill_protocol(
         "device_id": heatchill_id,
         "action_name": "heat_chill",
         "action_kwargs": {
-            "vessel": {"id": vessel},
+            "vessel": vessel,
             "temp": float(final_temp),
             "time": float(final_time),
             "stir": bool(stir),
@@ -287,8 +287,7 @@ def generate_heat_chill_start_protocol(
         "action_name": "heat_chill_start",
         "action_kwargs": {
             "temp": temp,
-            "purpose": purpose or f"开始加热到 {temp}°C",
-            "vessel": {"id": vessel_id},
+            "purpose": purpose or f"开始加热到 {temp}°C"
         }
     }]
     

unilabos/compile/run_column_protocol.py

@@ -2,7 +2,6 @@ from typing import List, Dict, Any, Union
 import networkx as nx
 import logging
 import re
-from .utils.vessel_parser import get_vessel
 from .pump_protocol import generate_pump_protocol_with_rinsing
 
 logger = logging.getLogger(__name__)
@@ -404,9 +403,9 @@ def generate_run_column_protocol(
     """
     
     # 🔧 核心修改：从字典中提取容器ID
-    from_vessel_id, _ = get_vessel(from_vessel)
-    to_vessel_id, _ = get_vessel(to_vessel)
-
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
+    
     debug_print("🏛️" * 20)
     debug_print("🚀 开始生成柱层析协议（支持vessel字典和体积运算）✨")
     debug_print(f"📝 输入参数:")
@@ -773,8 +772,8 @@ def generate_gradient_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vesse
                                     column: str, start_ratio: str = "10:90", 
                                     end_ratio: str = "50:50") -> List[Dict[str, Any]]:
     """梯度洗脱柱层析（中等比例）"""
-    from_vessel_id, _ = get_vessel(from_vessel)
-    to_vessel_id, _ = get_vessel(to_vessel)
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
     debug_print(f"📈 梯度柱层析: {from_vessel_id} → {to_vessel_id} ({start_ratio} → {end_ratio})")
     # 使用中间比例作为近似
     return generate_run_column_protocol(G, from_vessel, to_vessel, column, ratio="30:70")
@@ -782,8 +781,8 @@ def generate_gradient_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vesse
 def generate_polar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                  column: str) -> List[Dict[str, Any]]:
     """极性化合物柱层析（高极性溶剂比例）"""
-    from_vessel_id, _ = get_vessel(from_vessel)
-    to_vessel_id, _ = get_vessel(to_vessel)
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
     debug_print(f"⚡ 极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
     return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                       solvent1="ethyl_acetate", solvent2="hexane", ratio="70:30")
@@ -791,8 +790,8 @@ def generate_polar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel:
 def generate_nonpolar_column_protocol(G: nx.DiGraph, from_vessel: dict, to_vessel: dict, 
                                     column: str) -> List[Dict[str, Any]]:
     """非极性化合物柱层析（低极性溶剂比例）"""
-    from_vessel_id, _ = get_vessel(from_vessel)
-    to_vessel_id, _ = get_vessel(to_vessel)
+    from_vessel_id = from_vessel["id"]
+    to_vessel_id = to_vessel["id"]
     debug_print(f"🛢️ 非极性化合物柱层析: {from_vessel_id} → {to_vessel_id}")
     return generate_run_column_protocol(G, from_vessel, to_vessel, column, 
                                       solvent1="ethyl_acetate", solvent2="hexane", ratio="5:95")
@@ -805,3 +804,4 @@ def test_run_column_protocol():
 
 if __name__ == "__main__":
     test_run_column_protocol()
+

unilabos/compile/separate_protocol.py

@@ -265,7 +265,7 @@ def generate_separate_protocol(
                     "device_id": stirrer_device,
                     "action_name": "start_stir",
                     "action_kwargs": {
-                        "vessel": {"id": final_vessel_id},  # 🔧 使用 final_vessel_id
+                        "vessel": final_vessel_id,  # 🔧 使用 final_vessel_id
                         "stir_speed": stir_speed,
                         "purpose": f"分离混合 - {purpose}"
                     }

unilabos/compile/stir_protocol.py

@@ -234,7 +234,7 @@ def generate_stir_protocol(
         "action_name": "stir",
         "action_kwargs": {
             # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
-            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
+            "vessel": vessel_id,  # 传递字符串ID，不是Resource对象
             "time": str(time),
             "event": event,
             "time_spec": time_spec,
@@ -323,7 +323,7 @@ def generate_start_stir_protocol(
         "action_name": "start_stir",
         "action_kwargs": {
             # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
-            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
+            "vessel": vessel_id,  # 传递字符串ID，不是Resource对象
             "stir_speed": stir_speed,
             "purpose": purpose or f"启动搅拌 {stir_speed} RPM"
         }
@@ -383,7 +383,7 @@ def generate_stop_stir_protocol(
         "action_name": "stop_stir",
         "action_kwargs": {
             # 🔧 关键修复：传递vessel_id字符串，而不是完整的Resource对象
-            "vessel": {"id": vessel_id},  # 传递字符串ID，不是Resource对象
+            "vessel": vessel_id  # 传递字符串ID，不是Resource对象
         }
     }]
     

unilabos/compile/wash_solid_protocol.py

@@ -361,7 +361,7 @@ def generate_wash_solid_protocol(
                 "device_id": "stirrer_1",
                 "action_name": "stir",
                 "action_kwargs": {
-                    "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                    "vessel": vessel_id,  # 🔧 使用 vessel_id
                     "time": str(time),
                     "stir_time": final_time,
                     "stir_speed": stir_speed,
@@ -377,7 +377,7 @@ def generate_wash_solid_protocol(
             "device_id": "filter_1",
             "action_name": "filter",
             "action_kwargs": {
-                "vessel": {"id": vessel_id},  # 🔧 使用 vessel_id
+                "vessel": vessel_id,  # 🔧 使用 vessel_id
                 "filtrate_vessel": actual_filtrate_vessel,
                 "temp": temp,
                 "volume": final_volume

unilabos/device_comms/coin_cell_assembly_workstation.py

@@ -1,454 +0,0 @@
-"""
-纽扣电池组装工作站
-Coin Cell Assembly Workstation
-
-继承工作站基类，实现纽扣电池特定功能
-"""
-from typing import Dict, Any, List, Optional, Union
-
-from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
-from unilabos.device_comms.workstation_base import WorkstationBase, WorkflowInfo
-from unilabos.device_comms.workstation_communication import (
-    WorkstationCommunicationBase, CommunicationConfig, CommunicationProtocol, CoinCellCommunication
-)
-from unilabos.device_comms.workstation_material_management import (
-    MaterialManagementBase, CoinCellMaterialManagement
-)
-from unilabos.utils.log import logger
-
-
-class CoinCellAssemblyWorkstation(WorkstationBase):
-    """纽扣电池组装工作站
-    
-    基于工作站基类，实现纽扣电池制造的特定功能：
-    1. 纽扣电池特定的通信协议
-    2. 纽扣电池物料管理（料板、极片、电池等）
-    3. 电池制造工作流
-    4. 质量检查工作流
-    """
-
-    def __init__(
-        self,
-        device_id: str,
-        children: Dict[str, Dict[str, Any]],
-        protocol_type: Union[str, List[str]] = "BatteryManufacturingProtocol",
-        resource_tracker: Optional[DeviceNodeResourceTracker] = None,
-        modbus_config: Optional[Dict[str, Any]] = None,
-        deck_config: Optional[Dict[str, Any]] = None,
-        csv_path: str = "./coin_cell_assembly.csv",
-        *args,
-        **kwargs,
-    ):
-        # 设置通信配置
-        modbus_config = modbus_config or {"host": "127.0.0.1", "port": 5021}
-        self.communication_config = CommunicationConfig(
-            protocol=CommunicationProtocol.MODBUS_TCP,
-            host=modbus_config["host"],
-            port=modbus_config["port"],
-            timeout=modbus_config.get("timeout", 5.0),
-            retry_count=modbus_config.get("retry_count", 3)
-        )
-        
-        # 设置台面配置
-        self.deck_config = deck_config or {
-            "size_x": 1620.0,
-            "size_y": 1270.0,
-            "size_z": 500.0
-        }
-        
-        # CSV地址映射文件路径
-        self.csv_path = csv_path
-        
-        # 创建资源跟踪器（如果没有提供）
-        if resource_tracker is None:
-            from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
-            resource_tracker = DeviceNodeResourceTracker()
-        
-        # 初始化基类
-        super().__init__(
-            device_id=device_id,
-            children=children,
-            protocol_type=protocol_type,
-            resource_tracker=resource_tracker,
-            communication_config=self.communication_config,
-            deck_config=self.deck_config,
-            *args,
-            **kwargs
-        )
-        
-        logger.info(f"纽扣电池组装工作站 {device_id} 初始化完成")
-
-    def _create_communication_module(self) -> WorkstationCommunicationBase:
-        """创建纽扣电池通信模块"""
-        return CoinCellCommunication(
-            communication_config=self.communication_config,
-            csv_path=self.csv_path
-        )
-
-    def _create_material_management_module(self) -> MaterialManagementBase:
-        """创建纽扣电池物料管理模块"""
-        return CoinCellMaterialManagement(
-            device_id=self.device_id,
-            deck_config=self.deck_config,
-            resource_tracker=self.resource_tracker,
-            children_config=self.children
-        )
-
-    def _register_supported_workflows(self):
-        """注册纽扣电池工作流"""
-        # 电池制造工作流
-        self.supported_workflows["battery_manufacturing"] = WorkflowInfo(
-            name="battery_manufacturing",
-            description="纽扣电池制造工作流",
-            estimated_duration=300.0,  # 5分钟
-            required_materials=["cathode_sheet", "anode_sheet", "separator", "electrolyte"],
-            output_product="coin_cell_battery",
-            parameters_schema={
-                "type": "object",
-                "properties": {
-                    "electrolyte_num": {
-                        "type": "integer",
-                        "description": "电解液瓶数",
-                        "minimum": 1,
-                        "maximum": 32
-                    },
-                    "electrolyte_volume": {
-                        "type": "number",
-                        "description": "电解液体积 (μL)",
-                        "minimum": 0.1,
-                        "maximum": 100.0
-                    },
-                    "assembly_pressure": {
-                        "type": "number",
-                        "description": "组装压力 (N)",
-                        "minimum": 100.0,
-                        "maximum": 5000.0
-                    },
-                    "cathode_material": {
-                        "type": "string",
-                        "description": "正极材料类型",
-                        "enum": ["LiFePO4", "LiCoO2", "NCM", "LMO"]
-                    },
-                    "anode_material": {
-                        "type": "string", 
-                        "description": "负极材料类型",
-                        "enum": ["Graphite", "LTO", "Silicon"]
-                    }
-                },
-                "required": ["electrolyte_num", "electrolyte_volume", "assembly_pressure"]
-            }
-        )
-        
-        # 质量检查工作流
-        self.supported_workflows["quality_inspection"] = WorkflowInfo(
-            name="quality_inspection",
-            description="产品质量检查工作流",
-            estimated_duration=60.0,  # 1分钟
-            required_materials=["finished_battery"],
-            output_product="quality_report",
-            parameters_schema={
-                "type": "object",
-                "properties": {
-                    "test_voltage": {
-                        "type": "boolean",
-                        "description": "是否测试电压",
-                        "default": True
-                    },
-                    "test_capacity": {
-                        "type": "boolean",
-                        "description": "是否测试容量",
-                        "default": False
-                    },
-                    "voltage_threshold": {
-                        "type": "number",
-                        "description": "电压阈值 (V)",
-                        "minimum": 2.0,
-                        "maximum": 4.5,
-                        "default": 3.0
-                    }
-                }
-            }
-        )
-        
-        # 设备初始化工作流
-        self.supported_workflows["device_initialization"] = WorkflowInfo(
-            name="device_initialization", 
-            description="设备初始化工作流",
-            estimated_duration=30.0,  # 30秒
-            required_materials=[],
-            output_product="ready_status",
-            parameters_schema={
-                "type": "object",
-                "properties": {
-                    "auto_mode": {
-                        "type": "boolean",
-                        "description": "是否启用自动模式",
-                        "default": True
-                    }
-                }
-            }
-        )
-
-    # ============ 纽扣电池特定方法 ============
-    
-    def get_electrode_sheet_inventory(self) -> Dict[str, int]:
-        """获取极片库存统计"""
-        try:
-            sheets = self.material_management.find_electrode_sheets()
-            inventory = {}
-            
-            for sheet in sheets:
-                material_type = getattr(sheet, 'material_type', 'unknown')
-                inventory[material_type] = inventory.get(material_type, 0) + 1
-            
-            return inventory
-            
-        except Exception as e:
-            logger.error(f"获取极片库存失败: {e}")
-            return {}
-
-    def get_battery_production_statistics(self) -> Dict[str, Any]:
-        """获取电池生产统计"""
-        try:
-            production_data = self.communication.get_production_data()
-            
-            # 添加物料统计
-            electrode_inventory = self.get_electrode_sheet_inventory()
-            battery_count = len(self.material_management.find_batteries())
-            
-            return {
-                **production_data,
-                "electrode_inventory": electrode_inventory,
-                "finished_battery_count": battery_count,
-                "material_plates": len(self.material_management.find_material_plates()),
-                "press_slots": len(self.material_management.find_press_slots())
-            }
-            
-        except Exception as e:
-            logger.error(f"获取生产统计失败: {e}")
-            return {"error": str(e)}
-
-    def create_new_battery(self, battery_spec: Dict[str, Any]) -> Optional[str]:
-        """创建新电池资源"""
-        try:
-            from unilabos.device_comms.button_battery_station import Battery
-            import uuid
-            
-            battery_id = f"battery_{uuid.uuid4().hex[:8]}"
-            
-            battery = Battery(
-                name=battery_id,
-                diameter=battery_spec.get("diameter", 20.0),
-                height=battery_spec.get("height", 3.2),
-                max_volume=battery_spec.get("max_volume", 100.0),
-                barcode=battery_spec.get("barcode", "")
-            )
-            
-            # 添加到物料管理系统
-            self.material_management.plr_resources[battery_id] = battery
-            self.material_management.resource_tracker.add_resource(battery)
-            
-            logger.info(f"创建新电池资源: {battery_id}")
-            return battery_id
-            
-        except Exception as e:
-            logger.error(f"创建电池资源失败: {e}")
-            return None
-
-    def find_available_press_slot(self) -> Optional[str]:
-        """查找可用的压制槽"""
-        try:
-            press_slots = self.material_management.find_press_slots()
-            
-            for slot in press_slots:
-                if hasattr(slot, 'has_battery') and not slot.has_battery():
-                    return slot.name
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"查找可用压制槽失败: {e}")
-            return None
-
-    def get_glove_box_environment(self) -> Dict[str, Any]:
-        """获取手套箱环境数据"""
-        try:
-            device_status = self.communication.get_device_status()
-            environment = device_status.get("environment", {})
-            
-            return {
-                "pressure": environment.get("glove_box_pressure", 0.0),
-                "o2_content": environment.get("o2_content", 0.0),
-                "water_content": environment.get("water_content", 0.0),
-                "is_safe": (
-                    environment.get("o2_content", 0.0) < 10.0 and  # 氧气含量 < 10ppm
-                    environment.get("water_content", 0.0) < 1.0      # 水分含量 < 1ppm
-                )
-            }
-            
-        except Exception as e:
-            logger.error(f"获取手套箱环境失败: {e}")
-            return {"error": str(e)}
-
-    def start_data_export(self, file_path: str) -> bool:
-        """开始生产数据导出"""
-        try:
-            return self.communication.start_data_export(file_path, export_interval=5.0)
-        except Exception as e:
-            logger.error(f"启动数据导出失败: {e}")
-            return False
-
-    def stop_data_export(self) -> bool:
-        """停止生产数据导出"""
-        try:
-            return self.communication.stop_data_export()
-        except Exception as e:
-            logger.error(f"停止数据导出失败: {e}")
-            return False
-
-    # ============ 重写基类方法以支持纽扣电池特定功能 ============
-    
-    def start_workflow(self, workflow_type: str, parameters: Dict[str, Any] = None) -> bool:
-        """启动工作流（重写以支持纽扣电池特定预处理）"""
-        try:
-            # 进行纽扣电池特定的预检查
-            if workflow_type == "battery_manufacturing":
-                # 检查手套箱环境
-                env = self.get_glove_box_environment()
-                if not env.get("is_safe", False):
-                    logger.error("手套箱环境不安全，无法启动电池制造工作流")
-                    return False
-                
-                # 检查是否有可用的压制槽
-                available_slot = self.find_available_press_slot()
-                if not available_slot:
-                    logger.error("没有可用的压制槽，无法启动电池制造工作流")
-                    return False
-                
-                # 检查极片库存
-                electrode_inventory = self.get_electrode_sheet_inventory()
-                if not electrode_inventory.get("cathode", 0) > 0 or not electrode_inventory.get("anode", 0) > 0:
-                    logger.error("极片库存不足，无法启动电池制造工作流")
-                    return False
-            
-            # 调用基类方法
-            return super().start_workflow(workflow_type, parameters)
-            
-        except Exception as e:
-            logger.error(f"启动纽扣电池工作流失败: {e}")
-            return False
-
-    # ============ 纽扣电池特定状态属性 ============
-    
-    @property
-    def electrode_sheet_count(self) -> int:
-        """极片总数"""
-        try:
-            return len(self.material_management.find_electrode_sheets())
-        except:
-            return 0
-
-    @property
-    def battery_count(self) -> int:
-        """电池总数"""
-        try:
-            return len(self.material_management.find_batteries())
-        except:
-            return 0
-
-    @property
-    def available_press_slots(self) -> int:
-        """可用压制槽数"""
-        try:
-            press_slots = self.material_management.find_press_slots()
-            available = 0
-            for slot in press_slots:
-                if hasattr(slot, 'has_battery') and not slot.has_battery():
-                    available += 1
-            return available
-        except:
-            return 0
-
-    @property
-    def environment_status(self) -> Dict[str, Any]:
-        """环境状态"""
-        return self.get_glove_box_environment()
-
-
-# ============ 工厂函数 ============
-
-def create_coin_cell_workstation(
-    device_id: str,
-    config_file: str,
-    modbus_host: str = "127.0.0.1",
-    modbus_port: int = 5021,
-    csv_path: str = "./coin_cell_assembly.csv"
-) -> CoinCellAssemblyWorkstation:
-    """工厂函数：创建纽扣电池组装工作站
-    
-    Args:
-        device_id: 设备ID
-        config_file: 配置文件路径（JSON格式）
-        modbus_host: Modbus主机地址
-        modbus_port: Modbus端口
-        csv_path: 地址映射CSV文件路径
-    
-    Returns:
-        CoinCellAssemblyWorkstation: 工作站实例
-    """
-    import json
-    
-    try:
-        # 加载配置文件
-        with open(config_file, 'r', encoding='utf-8') as f:
-            config = json.load(f)
-        
-        # 提取配置
-        children = config.get("children", {})
-        deck_config = config.get("deck_config", {})
-        
-        # 创建工作站
-        workstation = CoinCellAssemblyWorkstation(
-            device_id=device_id,
-            children=children,
-            modbus_config={
-                "host": modbus_host,
-                "port": modbus_port
-            },
-            deck_config=deck_config,
-            csv_path=csv_path
-        )
-        
-        logger.info(f"纽扣电池工作站创建成功: {device_id}")
-        return workstation
-        
-    except Exception as e:
-        logger.error(f"创建纽扣电池工作站失败: {e}")
-        raise
-
-
-if __name__ == "__main__":
-    # 示例用法
-    workstation = create_coin_cell_workstation(
-        device_id="coin_cell_station_01",
-        config_file="./button_battery_workstation.json",
-        modbus_host="127.0.0.1",
-        modbus_port=5021
-    )
-    
-    # 启动电池制造工作流
-    success = workstation.start_workflow(
-        "battery_manufacturing",
-        {
-            "electrolyte_num": 16,
-            "electrolyte_volume": 50.0,
-            "assembly_pressure": 2000.0,
-            "cathode_material": "LiFePO4",
-            "anode_material": "Graphite"
-        }
-    )
-    
-    if success:
-        print("电池制造工作流启动成功")
-    else:
-        print("电池制造工作流启动失败")

unilabos/device_comms/modbus_plc/client.py

@@ -8,8 +8,8 @@ from pymodbus.client import ModbusSerialClient, ModbusTcpClient
 from pymodbus.framer import FramerType
 from typing import TypedDict
 
-from unilabos.device_comms.modbus_plc.modbus import DeviceType, HoldRegister, Coil, InputRegister, DiscreteInputs, DataType, WorderOrder
-from unilabos.device_comms.modbus_plc.modbus import Base as ModbusNodeBase
+from unilabos.device_comms.modbus_plc.node.modbus import DeviceType, HoldRegister, Coil, InputRegister, DiscreteInputs, DataType, WorderOrder
+from unilabos.device_comms.modbus_plc.node.modbus import Base as ModbusNodeBase
 from unilabos.device_comms.universal_driver import UniversalDriver
 from unilabos.utils.log import logger
 import pandas as pd

unilabos/device_comms/modbus_plc/test/client.py

@@ -1,6 +1,6 @@
 import time
 from pymodbus.client import ModbusTcpClient
-from unilabos.device_comms.modbus_plc.modbus import Coil, HoldRegister
+from unilabos.device_comms.modbus_plc.node.modbus import Coil, HoldRegister
 from pymodbus.payload import BinaryPayloadDecoder
 from pymodbus.constants import Endian
 

unilabos/device_comms/modbus_plc/test/node_test.py

@@ -1,6 +1,6 @@
 # coding=utf-8
 from pymodbus.client import ModbusTcpClient
-from unilabos.device_comms.modbus_plc.modbus import Coil
+from unilabos.device_comms.modbus_plc.node.modbus import Coil
 import time
 
 

unilabos/device_comms/modbus_plc/test/test_workflow.py

@@ -1,7 +1,7 @@
 import time
 from typing import Callable
 from unilabos.device_comms.modbus_plc.client import TCPClient, ModbusWorkflow, WorkflowAction, load_csv
-from unilabos.device_comms.modbus_plc.modbus import Base as ModbusNodeBase
+from unilabos.device_comms.modbus_plc.node.modbus import Base as ModbusNodeBase
 
 ############ 第一种写法 ##############
 

unilabos/device_mesh/devices/liquid_transform_xyz/macro_device.xacro

@@ -1,150 +0,0 @@
-<?xml version="1.0" ?>
-<robot name="liquid_transform_xyz" xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-
-  <xacro:macro name="liquid_transform_xyz" params="mesh_path:='' parent_link:='' station_name:='' device_name:='' x:=0 y:=0 z:=0 rx:=0 ry:=0 r:=0">
-
-    <joint name="${station_name}${device_name}base_link_joint" type="fixed">
-      <origin xyz="${x} ${y} ${z}" rpy="${rx} ${ry} ${r}" />
-      <parent link="${parent_link}"/>
-      <child link="${station_name}${device_name}device_link"/>
-      <axis xyz="0 0 0"/>
-    </joint>
-
-    <link name="${station_name}${device_name}device_link"/>
-    <joint name="${station_name}${device_name}device_link_joint" type="fixed">
-      <origin xyz="0 0 0" rpy="0 0 0" />
-      <parent link="${station_name}${device_name}device_link"/>
-      <child link="${station_name}${device_name}base_link"/>
-      <axis xyz="0 0 0"/>
-    </joint>
-
-    <!-- =================================================================================== -->
-    <!-- |    This document was autogenerated by xacro from xyz.urdf                       | -->
-    <!-- |    EDITING THIS FILE BY HAND IS NOT RECOMMENDED                                 | -->
-    <!-- =================================================================================== -->
-    <!-- This URDF was automatically created by SolidWorks to URDF Exporter! Originally created by Stephen Brawner (brawner@gmail.com) 
-         Commit Version: 1.6.0-4-g7f85cfe  Build Version: 1.6.7995.38578
-         For more information, please see http://wiki.ros.org/sw_urdf_exporter -->
-      <link name="${station_name}${device_name}base_link">
-        <inertial>
-          <origin rpy="0 0 0" xyz="0.15478184748283 0.171048654921622 0.119246989054835"/>
-          <mass value="10.6178517218032"/>
-          <inertia ixx="0.178863713357329" ixy="1.50019641847353E-05" ixz="1.35368730492005E-05" iyy="0.174395775755846" iyz="-9.90771939078091E-06" izz="0.34100152139765"/>
-        </inertial>
-        <visual>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/base_link.STL"/>
-          </geometry>
-          <material name="">
-            <color rgba="0.792156862745098 0.819607843137255 0.933333333333333 1"/>
-          </material>
-        </visual>
-        <collision>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/base_link.STL"/>
-          </geometry>
-        </collision>
-      </link>
-      <link name="${station_name}${device_name}x_link">
-        <inertial>
-          <origin rpy="0 0 0" xyz="0.325214039540178 0.00943452607370124 0.0482611114301988"/>
-          <mass value="2.10887387421016"/>
-          <inertia ixx="0.0012305846984949" ixy="5.54649260270946E-07" ixz="3.84099347741331E-07" iyy="0.0349382006090243" iyz="-0.000103697818531446" izz="0.0354178972785773"/>
-        </inertial>
-        <visual>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/x_link.STL"/>
-          </geometry>
-          <material name="">
-            <color rgba="0.792156862745098 0.819607843137255 0.933333333333333 1"/>
-          </material>
-        </visual>
-        <collision>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/x_link.STL"/>
-          </geometry>
-        </collision>
-      </link>
-      <joint name="${station_name}${device_name}x_joint" type="prismatic">
-        <origin rpy="0 0 0" xyz="-0.141499999999982 0.334850000000045 0.357700036886815"/>
-        <parent link="${station_name}${device_name}base_link"/>
-        <child link="${station_name}${device_name}x_link"/>
-        <axis xyz="0 1 0"/>
-        <limit effort="50" lower="-0.3" upper="0" velocity="1"/>
-      </joint>
-      <link name="${station_name}${device_name}y_link">
-        <inertial>
-          <origin rpy="0 0 0" xyz="-1.50235389641123E-05 -0.00104302241099613 -0.0439486470514941"/>
-          <mass value="0.57605998885478"/>
-          <inertia ixx="0.00193021581150653" ixy="3.53777102560584E-08" ixz="2.57202248177777E-07" iyy="0.00224712797067005" iyz="-3.96170906880708E-07" izz="0.000419338880142789"/>
-        </inertial>
-        <visual>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/y_link.STL"/>
-          </geometry>
-          <material name="">
-            <color rgba="0.792156862745098 0.819607843137255 0.933333333333333 1"/>
-          </material>
-        </visual>
-        <collision>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/y_link.STL"/>
-          </geometry>
-        </collision>
-      </link>
-      <joint name="${station_name}${device_name}y_joint" type="prismatic">
-        <origin rpy="0 0 0" xyz="0.2855 -0.0330000368868711 0.0578"/>
-        <parent link="${station_name}${device_name}x_link"/>
-        <child link="${station_name}${device_name}y_link"/>
-        <axis xyz="-1 0 0"/>
-        <limit effort="50" lower="-0.25" upper="0.25" velocity="1"/>
-      </joint>
-      <link name="${station_name}${device_name}z_link">
-        <inertial>
-          <origin rpy="0 0 0" xyz="-1.07272060046598E-06 -0.00954902784618396 0.017834416924223"/>
-          <mass value="0.199932032754258"/>
-          <inertia ixx="0.000219989530768707" ixy="-7.50956522121896E-10" ixz="-1.265045524863E-07" iyy="0.000245054780375167" iyz="-3.76753893185657E-06" izz="4.29092763044732E-05"/>
-        </inertial>
-        <visual>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/z_link.STL"/>
-          </geometry>
-          <material name="">
-            <color rgba="0.792156862745098 0.819607843137255 0.933333333333333 1"/>
-          </material>
-        </visual>
-        <collision>
-          <origin rpy="0 0 0" xyz="0 0 0"/>
-          <geometry>
-            <mesh filename="file://${mesh_path}/devices/liquid_transform_xyz/meshes/z_link.STL"/>
-          </geometry>
-        </collision>
-      </link>
-      <joint name="${station_name}${device_name}z_joint" type="prismatic">
-        <origin rpy="0 0 0" xyz="0.000950000000001387 -0.0737000000000002 0"/>
-        <parent link="${station_name}${device_name}y_link"/>
-        <child link="${station_name}${device_name}z_link"/>
-        <axis xyz="0 0 1"/>
-        <limit effort="50" lower="-0.2" upper="0" velocity="1"/>
-      </joint>
-      <link name="${station_name}${device_name}p_link">
-        
-      </link>
-      <joint name="${station_name}${device_name}p_joint" type="fixed">
-        <origin rpy="0 0 0" xyz="0 -0.0139999999999999 -0.10575"/>
-        <parent link="${station_name}${device_name}z_link"/>
-        <child link="${station_name}${device_name}p_link"/>
-        <axis xyz="0 0 0"/>
-      </joint>
-
-  </xacro:macro>
-
-</robot>

unilabos/devices/balance/__init__.py

@@ -1,6 +0,0 @@
-# Balance devices module
-
-# Import balance device modules
-from . import mettler_toledo_xpr
-
-__all__ = ['mettler_toledo_xpr']

unilabos/devices/balance/mettler_toledo_xpr/MT.Laboratory.Balance.XprXsr.V03.wsdl.template

@@ -1,51 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- 
-  WSDL Template for Mettler Toledo XPR/XSR Balance
-  
-  IMPORTANT: This is a template file. You need to obtain the actual WSDL file 
-  from Mettler Toledo for your specific balance model.
-  
-  To use this driver:
-  1. Contact Mettler Toledo support to obtain the official WSDL file
-  2. Replace this template with the actual WSDL file
-  3. Rename it to: MT.Laboratory.Balance.XprXsr.V03.wsdl
-  
-  The WSDL file contains proprietary information and cannot be distributed
-  with this open-source project.
--->
-<wsdl:definitions xmlns:wsx="http://schemas.xmlsoap.org/ws/2004/09/mex" 
-                  xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" 
-                  xmlns:wsa10="http://www.w3.org/2005/08/addressing" 
-                  xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" 
-                  xmlns:wsap="http://schemas.xmlsoap.org/ws/2004/08/addressing/policy" 
-                  xmlns:msc="http://schemas.microsoft.com/ws/2005/12/wsdl/contract" 
-                  xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" 
-                  xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" 
-                  xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" 
-                  xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
-                  xmlns:tns="http://MT/Laboratory/Balance/XprXsr/V03" 
-                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" 
-                  xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl" 
-                  xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" 
-                  targetNamespace="http://MT/Laboratory/Balance/XprXsr/V03" 
-                  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
-  
-  <!-- 
-    PLACEHOLDER CONTENT
-    
-    This template contains only the basic structure.
-    The actual WSDL file should contain:
-    - Service definitions
-    - Port types
-    - Message definitions
-    - Binding information
-    - Endpoint addresses with template variables: {{host}}, {{port}}, {{api_path}}
-  -->
-  
-  <wsdl:types>
-    <!-- Schema definitions will be here in the actual WSDL -->
-  </wsdl:types>
-  
-  <!-- Service definitions will be here in the actual WSDL -->
-  
-</wsdl:definitions>

unilabos/devices/balance/mettler_toledo_xpr/Mettler_Toledo_Balance_ROS2_User_Guide.md

@@ -1,255 +0,0 @@
-# 梅特勒天平 ROS2 使用指南 / Mettler Toledo Balance ROS2 User Guide
-
-## 概述 / Overview
-
-梅特勒托利多XPR/XSR天平驱动支持通过ROS2动作进行操作，包括去皮、清零、读取重量等功能。
-
-The Mettler Toledo XPR/XSR balance driver supports operations through ROS2 actions, including tare, zero, weight reading, and other functions.
-
-## 主要功能 / Main Features
-
-### 1. 去皮操作 / Tare Operation (`tare`)
-
-- **功能 / Function**: 执行天平去皮操作 / Perform balance tare operation
-- **输入 / Input**: `{"immediate": bool}` - 是否立即去皮 / Whether to tare immediately
-- **输出 / Output**: `{"return_info": str, "success": bool}`
-
-### 2. 清零操作 / Zero Operation (`zero`)
-
-- **功能 / Function**: 执行天平清零操作 / Perform balance zero operation
-- **输入 / Input**: `{"immediate": bool}` - 是否立即清零 / Whether to zero immediately
-- **输出 / Output**: `{"return_info": str, "success": bool}`
-
-### 3. 读取重量 / Read Weight (`read` / `get_weight`)
-
-- **功能 / Function**: 读取当前天平重量 / Read current balance weight
-- **输入 / Input**: 无参数 / No parameters
-- **输出 / Output**: `{"return_info": str, "success": bool}` - 包含重量信息 / Contains weight information
-
-
-
-## 使用方法 / Usage Methods
-
-### ROS2命令行使用 / ROS2 Command Line Usage
-
-### 1. 去皮操作 / Tare Operation
-
-```bash
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"tare\", \"params\": {\"immediate\": false}}'
-}"
-```
-
-### 2. 清零操作 / Zero Operation
-
-```bash
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"zero\", \"params\": {\"immediate\": false}}'
-}"
-```
-
-### 3. 读取重量 / Read Weight
-
-```bash
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"read\"}'
-}"
-```
-
-
-### 4. 推荐的去皮读取流程 / Recommended Tare and Read Workflow
-
-**步骤1: 去皮操作 / Step 1: Tare Operation**
-```bash
-# 放置空容器后执行去皮 / Execute tare after placing empty container
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"tare\", \"params\": {\"immediate\": false}}'
-}"
-```
-
-**步骤2: 读取净重 / Step 2: Read Net Weight**
-```bash
-# 添加物质后读取净重 / Read net weight after adding substance
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"read\"}'
-}"
-```
-
-**优势 / Advantages**:
-- 可以在去皮和读取之间进行确认 / Can confirm between taring and reading
-- 更好的错误处理和调试 / Better error handling and debugging
-- 操作流程更加清晰 / Clearer operation workflow
-
-
-
-## 命令格式说明 / Command Format Description
-
-所有命令都使用JSON格式，包含以下字段 / All commands use JSON format with the following fields：
-
-```json
-{
-  "command": "命令名称 / Command name",
-  "params": {
-    "参数名 / Parameter name": "参数值 / Parameter value"
-  }
-}
-```
-
-**注意事项 / Notes：**
-1. JSON字符串需要正确转义引号 / JSON strings need proper quote escaping
-2. 布尔值使用小写（true/false）/ Boolean values use lowercase (true/false)
-3. 如果命令不需要参数，可以省略`params`字段 / If command doesn't need parameters, `params` field can be omitted
-
-## 返回结果 / Return Results
-
-所有命令都会返回包含以下字段的结果 / All commands return results with the following fields：
-
-- `success`: 布尔值，表示操作是否成功 / Boolean value indicating operation success
-- `return_info`: 字符串，包含操作结果的详细信息 / String containing detailed operation result information
-
-## 成功执行示例 / Successful Execution Example
-
-以下是一个成功执行读取重量命令的示例 / Here is an example of successfully executing a weight reading command：
-
-```bash
-ros2 action send_goal /devices/BALANCE_STATION/send_cmd unilabos_msgs/action/SendCmd "{
-  command: '{\"command\": \"read\"}'
-}"
-```
-
-**成功返回结果 / Successful Return Result：**
-```
-Waiting for an action server to become available...
-Sending goal:
-     command: '{"command": "read"}'
-
-Goal accepted :)
-
-Result:
-    success: True
-    return_info: Weight: 0.24866 Milligram
-
-Goal finished with status: SUCCEEDED
-```
-
-### Python代码使用 / Python Code Usage
-
-```python
-import rclpy
-from rclpy.node import Node
-from rclpy.action import ActionClient
-from unilabos_msgs.action import SendCmd
-import json
-
-class BalanceController(Node):
-    """梅特勒天平控制器 / Mettler Balance Controller"""
-    def __init__(self):
-        super().__init__('balance_controller')
-        self._action_client = ActionClient(self, SendCmd, '/devices/BALANCE_STATION/send_cmd')
-    
-    def send_command(self, command, params=None):
-        """发送命令到天平 / Send command to balance"""
-        goal_msg = SendCmd.Goal()
-        
-        cmd_data = {'command': command}
-        if params:
-            cmd_data['params'] = params
-            
-        goal_msg.command = json.dumps(cmd_data)
-        
-        self._action_client.wait_for_server()
-        future = self._action_client.send_goal_async(goal_msg)
-        
-        return future
-    
-    def tare_balance(self, immediate=False):
-        """去皮操作 / Tare operation"""
-        return self.send_command('tare', {'immediate': immediate})
-    
-    def zero_balance(self, immediate=False):
-        """清零操作 / Zero operation"""
-        return self.send_command('zero', {'immediate': immediate})
-    
-    def read_weight(self):
-        """读取重量 / Read weight"""
-        return self.send_command('read')
-    
-
-
-
-# 使用示例 / Usage Example
-def main():
-    rclpy.init()
-    controller = BalanceController()
-    
-    # 去皮操作 / Tare operation
-    future = controller.tare_balance(immediate=False)
-    rclpy.spin_until_future_complete(controller, future)
-    result = future.result().result
-    print(f"去皮结果 / Tare result: {result.success}, 信息 / Info: {result.return_info}")
-    
-    # 读取重量 / Read weight
-    future = controller.read_weight()
-    rclpy.spin_until_future_complete(controller, future)
-    result = future.result().result
-    print(f"读取结果 / Read result: {result.success}, 信息 / Info: {result.return_info}")
-    
-    controller.destroy_node()
-    rclpy.shutdown()
-
-if __name__ == '__main__':
-    main()
-```
-
-## 使用注意事项 / Usage Notes
-
-1. **设备连接 / Device Connection**: 确保梅特勒天平设备已连接并可访问 / Ensure Mettler balance device is connected and accessible
-2. **命令格式 / Command Format**: JSON字符串需要正确转义引号 / JSON strings need proper quote escaping
-3. **参数类型 / Parameter Types**: 布尔值使用小写（true/false）/ Boolean values use lowercase (true/false)
-4. **权限 / Permissions**: 确保有操作天平的权限 / Ensure you have permission to operate the balance
-
-## 故障排除 / Troubleshooting
-
-### 常见问题 / Common Issues
-
-1. **JSON格式错误 / JSON Format Error**: 确保JSON字符串格式正确且引号已转义 / Ensure JSON string format is correct and quotes are escaped
-2. **未知命令名称 / Unknown Command Name**: 检查命令名称是否正确 / Check if command name is correct
-3. **设备连接失败 / Device Connection Failed**: 检查网络连接和设备状态 / Check network connection and device status
-4. **操作超时 / Operation Timeout**: 检查设备是否响应正常 / Check if device is responding normally
-
-### 错误处理 / Error Handling
-
-如果命令执行失败，返回结果中的`success`字段将为`false`，`return_info`字段将包含错误信息。
-
-If command execution fails, the `success` field in the return result will be `false`, and the `return_info` field will contain error information.
-
-### 调试技巧 / Debugging Tips
-
-1. 检查设备节点是否正在运行 / Check if device node is running：
-   ```bash
-   ros2 node list | grep BALANCE
-   ```
-
-2. 查看可用的action / View available actions：
-   ```bash
-   ros2 action list | grep BALANCE
-   ```
-
-3. 检查action接口 / Check action interface：
-   ```bash
-   ros2 action info /devices/BALANCE_STATION/send_cmd
-   ```
-
-4. 查看节点日志 / View node logs：
-   ```bash
-   ros2 topic echo /rosout
-   ```
-
-## 总结 / Summary
-
-梅特勒托利多天平设备现在支持 / Mettler Toledo balance device now supports:
-
-1. 通过ROS2 SendCmd动作进行统一操作 / Unified operations through ROS2 SendCmd actions
-2. 完整的天平功能支持（去皮、清零、读重等）/ Complete balance function support (tare, zero, weight reading, etc.)
-3. 完善的错误处理和日志记录 / Comprehensive error handling and logging
-4. 简化的操作流程和调试方法 / Simplified operation workflow and debugging methods

unilabos/devices/balance/mettler_toledo_xpr/README.md

@@ -1,123 +0,0 @@
-# Mettler Toledo XPR/XSR Balance Driver
-
-## 概述
-
-本驱动程序为梅特勒托利多XPR/XSR系列天平提供标准接口，支持去皮、清零和重量读取等操作。
-
-## ⚠️ 重要说明 - WSDL文件配置
-
-### 问题说明
-
-本驱动程序需要使用梅特勒托利多官方提供的WSDL文件来与天平通信。由于该WSDL文件包含专有信息，不能随开源项目一起分发。
-
-### 配置步骤
-
-1. **获取WSDL文件**
-   - 联系梅特勒托利多技术支持
-   - 或从您的天平设备Web界面下载
-   - 或从梅特勒托利多官方SDK获取
-
-2. **安装WSDL文件**
-   ```bash
-   # 将获取的WSDL文件复制到驱动目录
-   cp /path/to/your/MT.Laboratory.Balance.XprXsr.V03.wsdl \
-      unilabos/devices/balance/mettler_toledo_xpr/
-   ```
-
-3. **验证安装**
-   - 确保文件名为：`MT.Laboratory.Balance.XprXsr.V03.wsdl`
-   - 确保文件包含Jinja2模板变量：`{{host}}`、`{{port}}`、`{{api_path}}`
-
-### WSDL文件要求
-
-- 文件必须是有效的WSDL格式
-- 必须包含SessionService和WeighingService的定义
-- 端点地址应使用模板变量以支持动态IP配置：
-  ```xml
-  <soap:address location="http://{{host}}:{{port}}/{{api_path}}/SessionService" />
-  <soap:address location="http://{{host}}:{{port}}/{{api_path}}/WeighingService" />
-  ```
-
-### 文件结构
-
-```
-mettler_toledo_xpr/
-├── MT.Laboratory.Balance.XprXsr.V03.wsdl          # 实际WSDL文件（用户提供）
-├── MT.Laboratory.Balance.XprXsr.V03.wsdl.template # 模板文件（仅供参考）
-├── mettler_toledo_xpr.py                          # 驱动程序
-├── balance.yaml                                   # 设备配置
-├── SendCmd_Usage_Guide.md                         # 使用指南
-└── README.md                                      # 本文件
-```
-
-## 使用方法
-
-### 基本配置
-
-```python
-from unilabos.devices.balance.mettler_toledo_xpr import MettlerToledoXPR
-
-# 创建天平实例
-balance = MettlerToledoXPR(
-    ip="192.168.1.10",      # 天平IP地址
-    port=81,                # 天平端口
-    password="123456",      # 天平密码
-    timeout=10              # 连接超时时间
-)
-
-# 执行操作
-balance.tare()              # 去皮
-balance.zero()              # 清零
-weight = balance.get_weight()  # 读取重量
-```
-
-### ROS2 SendCmd Action
-
-详细的ROS2使用方法请参考 [SendCmd_Usage_Guide.md](SendCmd_Usage_Guide.md)
-
-## 故障排除
-
-### 常见错误
-
-1. **FileNotFoundError: WSDL template not found**
-   - 确保WSDL文件已正确放置在驱动目录中
-   - 检查文件名是否正确
-
-2. **连接失败**
-   - 检查天平IP地址和端口配置
-   - 确保天平Web服务已启用
-   - 验证网络连接
-
-3. **认证失败**
-   - 检查天平密码是否正确
-   - 确保天平允许Web服务访问
-
-### 调试模式
-
-```python
-import logging
-logging.basicConfig(level=logging.DEBUG)
-
-# 创建天平实例，将显示详细日志
-balance = MettlerToledoXPR(ip="192.168.1.10")
-```
-
-## 支持的操作
-
-- **去皮 (Tare)**: 将当前重量设为零点
-- **清零 (Zero)**: 重新校准零点
-- **读取重量 (Get Weight)**: 获取当前重量值
-- **带去皮读取**: 先去皮再读取重量
-- **连接管理**: 自动连接和断开
-
-## 技术支持
-
-如果您在配置WSDL文件时遇到问题，请：
-
-1. 查看梅特勒托利多官方文档
-2. 联系梅特勒托利多技术支持
-3. 在项目GitHub页面提交Issue
-
-## 许可证
-
-本驱动程序遵循项目主许可证。WSDL文件的使用需遵循梅特勒托利多的许可条款。

unilabos/devices/balance/mettler_toledo_xpr/__init__.py

@@ -1,5 +0,0 @@
-# Mettler Toledo XPR Balance Driver Module
-
-from .mettler_toledo_xpr import MettlerToledoXPR
-
-__all__ = ['MettlerToledoXPR']

unilabos/devices/balance/mettler_toledo_xpr/balance.yaml

@@ -1,256 +0,0 @@
-balance.mettler_toledo_xpr:
-  category:
-  - balance
-  class:
-    action_value_mappings:
-      disconnect:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result:
-          success: success
-        schema:
-          description: Disconnect from balance
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                success:
-                  description: Whether disconnect was successful
-                  type: boolean
-              required:
-              - success
-              type: object
-          required:
-          - goal
-          type: object
-        type: UniLabJsonCommand
-      get_weight:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: []
-        result:
-          unit: unit
-          weight: weight
-        schema:
-          description: Get current weight reading
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result:
-              properties:
-                unit:
-                  description: Weight unit (e.g., g, kg)
-                  type: string
-                weight:
-                  description: Weight value
-                  type: number
-              required:
-              - weight
-              - unit
-              type: object
-          required:
-          - goal
-          type: object
-        type: UniLabJsonCommand
-      read_with_tare:
-        feedback: {}
-        goal:
-          immediate_tare: immediate_tare
-        goal_default:
-          immediate_tare: true
-        handles: []
-        result:
-          unit: unit
-          weight: weight
-        schema:
-          description: Perform tare then read weight (standard read operation)
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                immediate_tare:
-                  default: true
-                  description: Whether to use immediate tare
-                  type: boolean
-              required: []
-              type: object
-            result:
-              properties:
-                unit:
-                  description: Weight unit (e.g., g, kg)
-                  type: string
-                weight:
-                  description: Weight value after tare
-                  type: number
-              required:
-              - weight
-              - unit
-              type: object
-          required:
-          - goal
-          type: object
-        type: UniLabJsonCommand
-      send_cmd:
-        feedback: {}
-        goal:
-          command: command
-        goal_default:
-          command: ''
-        handles: []
-        result:
-          return_info: return_info
-          success: success
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties:
-                status:
-                  type: string
-              required:
-              - status
-              title: SendCmd_Feedback
-              type: object
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              title: SendCmd_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: SendCmd_Result
-              type: object
-          required:
-          - goal
-          title: SendCmd
-          type: object
-        type: SendCmd
-      tare:
-        feedback: {}
-        goal:
-          immediate: immediate
-        goal_default:
-          immediate: false
-        handles: []
-        result:
-          success: success
-        schema:
-          description: Tare operation for balance
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                immediate:
-                  default: false
-                  description: Whether to perform immediate tare
-                  type: boolean
-              required: []
-              type: object
-            result:
-              properties:
-                success:
-                  description: Whether tare operation was successful
-                  type: boolean
-              required:
-              - success
-              type: object
-          required:
-          - goal
-          type: object
-        type: UniLabJsonCommand
-      zero:
-        feedback: {}
-        goal:
-          immediate: immediate
-        goal_default:
-          immediate: false
-        handles: []
-        result:
-          success: success
-        schema:
-          description: Zero operation for balance
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                immediate:
-                  default: false
-                  description: Whether to perform immediate zero
-                  type: boolean
-              required: []
-              type: object
-            result:
-              properties:
-                success:
-                  description: Whether zero operation was successful
-                  type: boolean
-              required:
-              - success
-              type: object
-          required:
-          - goal
-          type: object
-        type: UniLabJsonCommand
-    module: unilabos.devices.balance.mettler_toledo_xpr.mettler_toledo_xpr:MettlerToledoXPR
-    status_types:
-      error_message: str
-      is_stable: bool
-      status: str
-      unit: str
-      weight: float
-    type: python
-  config_info: []
-  description: Mettler Toledo XPR/XSR Balance Driver
-  handles: []
-  icon: ''
-  init_param_schema:
-    description: MettlerToledoXPR __init__ parameters
-    properties:
-      feedback: {}
-      goal:
-        description: Initialization parameters for Mettler Toledo XPR balance
-        properties:
-          ip:
-            default: 192.168.1.10
-            description: Balance IP address
-            type: string
-          password:
-            default: '123456'
-            description: Balance password
-            type: string
-          port:
-            default: 81
-            description: Balance port number
-            type: integer
-          timeout:
-            default: 10
-            description: Connection timeout in seconds
-            type: integer
-        required: []
-        type: object
-      result: {}
-    required:
-    - goal
-    title: __init__ command parameters
-    type: object
-  version: 1.0.0

unilabos/devices/balance/mettler_toledo_xpr/balance_test.json

@@ -1,25 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "BALANCE_STATION",
-            "name": "METTLER_TOLEDO_XPR",
-            "parent": null,
-            "type": "device",
-            "class": "balance.mettler_toledo_xpr",
-            "position": {
-                "x": 620.6111111111111,
-                "y": 171,
-                "z": 0
-            },
-            "config": {
-                "ip": "192.168.1.10",
-                "port": 81,
-                "password": "123456",
-                "timeout": 10
-            },
-            "data": {},
-            "children": []
-        }
-    ],
-  "links": []
-}

unilabos/devices/balance/mettler_toledo_xpr/mettler_toledo_xpr.py

@@ -1,571 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-Mettler Toledo XPR/XSR Balance Driver for Uni-Lab OS
-
-This driver provides standard interface for Mettler Toledo XPR/XSR balance operations
-including tare, zero, and weight reading functions.
-"""
-
-import enum
-import base64
-import hashlib
-import logging
-import time
-from pathlib import Path
-from decimal import Decimal
-from typing import Tuple, Optional
-
-from jinja2 import Template
-from requests import Session
-from zeep import Client
-from zeep.transports import Transport
-import pprp
-
-# Import UniversalDriver - handle import error gracefully
-try:
-    from unilabos.device_comms.universal_driver import UniversalDriver
-except ImportError:
-    # Fallback for standalone testing
-    class UniversalDriver:
-        """Fallback UniversalDriver for standalone testing"""
-        def __init__(self):
-            self.success = False
-
-
-class Outcome(enum.Enum):
-    """Balance operation outcome enumeration"""
-    SUCCESS = "Success"
-    ERROR = "Error"
-
-
-class MettlerToledoXPR(UniversalDriver):
-    """Mettler Toledo XPR/XSR Balance Driver
-    
-    Provides standard interface for balance operations including:
-    - Tare (去皮)
-    - Zero (清零) 
-    - Weight reading (读数)
-    """
-    
-    def __init__(self, ip: str = "192.168.1.10", port: int = 81, 
-                 password: str = "123456", timeout: int = 10):
-        """Initialize the balance driver
-        
-        Args:
-            ip: Balance IP address
-            port: Balance port number
-            password: Balance password
-            timeout: Connection timeout in seconds
-        """
-        super().__init__()
-        
-        self.ip = ip
-        self.port = port
-        self.password = password
-        self.timeout = timeout
-        self.api_path = "MT/Laboratory/Balance/XprXsr/V03"
-        
-        # Status properties
-        self._status = "Disconnected"
-        self._last_weight = 0.0
-        self._last_unit = "g"
-        self._is_stable = False
-        self._error_message = ""
-        
-        # ROS2 action result properties
-        self.success = False
-        self.return_info = ""
-        
-        # Service objects
-        self.client = None
-        self.session_svc = None
-        self.weighing_svc = None
-        self.session_id = None
-        
-        # WSDL template path
-        self.wsdl_template = Path(__file__).parent / "MT.Laboratory.Balance.XprXsr.V03.wsdl"
-        
-        # Bindings
-        self.bindings = {
-            "session": "{http://MT/Laboratory/Balance/XprXsr/V03}BasicHttpBinding_ISessionService",
-            "weigh": "{http://MT/Laboratory/Balance/XprXsr/V03}BasicHttpBinding_IWeighingService",
-        }
-        
-        # Setup logging
-        self.logger = logging.getLogger(f"MettlerToledoXPR-{ip}")
-        
-        # Initialize connection
-        self._connect()
-    
-    @property
-    def status(self) -> str:
-        """Current device status"""
-        return self._status
-    
-    @property
-    def weight(self) -> float:
-        """Last measured weight value"""
-        return self._last_weight
-    
-    @property
-    def unit(self) -> str:
-        """Weight unit (e.g., 'g', 'kg')"""
-        return self._last_unit
-    
-    @property
-    def is_stable(self) -> bool:
-        """Whether the weight reading is stable"""
-        return self._is_stable
-    
-    @property
-    def error_message(self) -> str:
-        """Last error message"""
-        return self._error_message
-    
-    def _decrypt_session_id(self, pw: str, enc_sid: str, salt: str) -> str:
-        """Decrypt session ID using password and salt"""
-        key = hashlib.pbkdf2_hmac("sha1", pw.encode(),
-                                  base64.b64decode(salt), 1000, dklen=32)
-        plain = pprp.decrypt_sink(
-            pprp.rijndael_decrypt_gen(
-                key, pprp.data_source_gen(base64.b64decode(enc_sid))))
-        return plain.decode()
-    
-    def _render_wsdl(self) -> Path:
-        """Render WSDL template with current connection parameters"""
-        if not self.wsdl_template.exists():
-            raise FileNotFoundError(f"WSDL template not found: {self.wsdl_template}")
-        
-        text = Template(self.wsdl_template.read_text(encoding="utf-8")).render(
-            host=self.ip, port=self.port, api_path=self.api_path)
-        
-        wsdl_path = self.wsdl_template.parent / f"rendered_{self.ip}_{self.port}.wsdl"
-        wsdl_path.write_text(text, encoding="utf-8")
-        
-        return wsdl_path
-    
-    def _connect(self):
-        """Establish connection to the balance"""
-        try:
-            self._status = "Connecting"
-            
-            # Render WSDL
-            wsdl_path = self._render_wsdl()
-            self.logger.info(f"WSDL rendered to {wsdl_path}")
-            
-            # Create SOAP client
-            transport = Transport(session=Session(), timeout=self.timeout)
-            self.client = Client(wsdl=str(wsdl_path), transport=transport)
-            
-            # Create service proxies
-            base_url = f"http://{self.ip}:{self.port}/{self.api_path}"
-            self.session_svc = self.client.create_service(
-                self.bindings["session"], f"{base_url}/SessionService")
-            self.weighing_svc = self.client.create_service(
-                self.bindings["weigh"], f"{base_url}/WeighingService")
-            
-            self.logger.info("Zeep service proxies created")
-            
-            # Open session
-            self.logger.info("Opening session...")
-            reply = self.session_svc.OpenSession()
-            if reply.Outcome != Outcome.SUCCESS.value:
-                raise RuntimeError(f"OpenSession failed: {getattr(reply, 'ErrorMessage', '')}")
-            
-            self.session_id = self._decrypt_session_id(
-                self.password, reply.SessionId, reply.Salt)
-            
-            self.logger.info(f"Session established successfully, SessionId={self.session_id}")
-            self._status = "Connected"
-            self._error_message = ""
-            
-        except Exception as e:
-            self._status = "Error"
-            self._error_message = str(e)
-            self.logger.error(f"Connection failed: {e}")
-            raise
-    
-    def _ensure_connected(self):
-        """Ensure the device is connected"""
-        if self._status != "Connected" or self.session_id is None:
-            self._connect()
-    
-    def tare(self, immediate: bool = False) -> bool:
-        """Perform tare operation (去皮)
-        
-        Args:
-            immediate: Whether to perform immediate tare
-            
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        try:
-            self._ensure_connected()
-            self._status = "Taring"
-            
-            self.logger.info(f"Performing tare (immediate={immediate})...")
-            reply = self.weighing_svc.Tare(self.session_id, immediate)
-            
-            if reply.Outcome != Outcome.SUCCESS.value:
-                error_msg = getattr(reply, 'ErrorMessage', 'Unknown error')
-                self.logger.error(f"Tare failed: {error_msg}")
-                self._error_message = f"Tare failed: {error_msg}"
-                self._status = "Error"
-                return False
-            
-            self.logger.info("Tare completed successfully")
-            self._status = "Connected"
-            self._error_message = ""
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Tare operation failed: {e}")
-            self._error_message = str(e)
-            self._status = "Error"
-            return False
-    
-    def zero(self, immediate: bool = False) -> bool:
-        """Perform zero operation (清零)
-        
-        Args:
-            immediate: Whether to perform immediate zero
-            
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        try:
-            self._ensure_connected()
-            self._status = "Zeroing"
-            
-            self.logger.info(f"Performing zero (immediate={immediate})...")
-            reply = self.weighing_svc.Zero(self.session_id, immediate)
-            
-            if reply.Outcome != Outcome.SUCCESS.value:
-                error_msg = getattr(reply, 'ErrorMessage', 'Unknown error')
-                self.logger.error(f"Zero failed: {error_msg}")
-                self._error_message = f"Zero failed: {error_msg}"
-                self._status = "Error"
-                return False
-            
-            self.logger.info("Zero completed successfully")
-            self._status = "Connected"
-            self._error_message = ""
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Zero operation failed: {e}")
-            self._error_message = str(e)
-            self._status = "Error"
-            return False
-    
-    def get_weight(self) -> float:
-        """Get current weight reading (读数)
-        
-        Returns:
-            float: Weight value
-        """
-        try:
-            self._ensure_connected()
-            self._status = "Reading"
-            
-            self.logger.info("Getting weight...")
-            reply = self.weighing_svc.GetWeight(self.session_id)
-            
-            if reply.Outcome != Outcome.SUCCESS.value:
-                error_msg = getattr(reply, 'ErrorMessage', 'Unknown error')
-                self.logger.error(f"GetWeight failed: {error_msg}")
-                self._error_message = f"GetWeight failed: {error_msg}"
-                self._status = "Error"
-                return 0.0
-            
-            # Handle different response structures
-            if hasattr(reply, 'WeightSample'):
-                # Handle WeightSample structure (most common for XPR)
-                weight_sample = reply.WeightSample
-                if hasattr(weight_sample, 'NetWeight'):
-                    weight_val = float(Decimal(weight_sample.NetWeight.Value))
-                    weight_unit = weight_sample.NetWeight.Unit
-                elif hasattr(weight_sample, 'GrossWeight'):
-                    weight_val = float(Decimal(weight_sample.GrossWeight.Value))
-                    weight_unit = weight_sample.GrossWeight.Unit
-                else:
-                    weight_val = 0.0
-                    weight_unit = 'g'
-                is_stable = getattr(weight_sample, 'Stable', True)
-            elif hasattr(reply, 'Weight'):
-                weight_val = float(Decimal(reply.Weight.Value))
-                weight_unit = reply.Weight.Unit
-                is_stable = getattr(reply.Weight, 'IsStable', True)
-            elif hasattr(reply, 'Value'):
-                weight_val = float(Decimal(reply.Value))
-                weight_unit = getattr(reply, 'Unit', 'g')
-                is_stable = getattr(reply, 'IsStable', True)
-            else:
-                # Try to extract from reply attributes
-                weight_val = float(Decimal(getattr(reply, 'WeightValue', getattr(reply, 'Value', '0'))))
-                weight_unit = getattr(reply, 'WeightUnit', getattr(reply, 'Unit', 'g'))
-                is_stable = getattr(reply, 'IsStable', True)
-            
-            # Convert to grams for consistent output (ROS2 requirement)
-            if weight_unit.lower() in ['milligram', 'mg']:
-                weight_val_grams = weight_val / 1000.0
-            elif weight_unit.lower() in ['kilogram', 'kg']:
-                weight_val_grams = weight_val * 1000.0
-            elif weight_unit.lower() in ['gram', 'g']:
-                weight_val_grams = weight_val
-            else:
-                # Default to assuming grams if unit is unknown
-                weight_val_grams = weight_val
-                self.logger.warning(f"Unknown weight unit: {weight_unit}, assuming grams")
-            
-            # Update internal state (keep original values for reference)
-            self._last_weight = weight_val
-            self._last_unit = weight_unit
-            self._is_stable = is_stable
-            
-            self.logger.info(f"Weight: {weight_val_grams} g (original: {weight_val} {weight_unit})")
-            self._status = "Connected"
-            self._error_message = ""
-            
-            return weight_val_grams
-            
-        except Exception as e:
-            self.logger.error(f"Get weight failed: {e}")
-            self._error_message = str(e)
-            self._status = "Error"
-            return 0.0
-    
-    def get_weight_with_unit(self) -> Tuple[float, str]:
-        """Get current weight reading with unit (读数含单位)
-        
-        Returns:
-            Tuple[float, str]: Weight value and unit
-        """
-        try:
-            self._ensure_connected()
-            self._status = "Reading"
-            
-            self.logger.info("Getting weight with unit...")
-            reply = self.weighing_svc.GetWeight(self.session_id)
-            
-            if reply.Outcome != Outcome.SUCCESS.value:
-                error_msg = getattr(reply, 'ErrorMessage', 'Unknown error')
-                self.logger.error(f"GetWeight failed: {error_msg}")
-                self._error_message = f"GetWeight failed: {error_msg}"
-                self._status = "Error"
-                return 0.0, ""
-            
-            # Handle different response structures
-            if hasattr(reply, 'WeightSample'):
-                # Handle WeightSample structure (most common for XPR)
-                weight_sample = reply.WeightSample
-                if hasattr(weight_sample, 'NetWeight'):
-                    weight_val = float(Decimal(weight_sample.NetWeight.Value))
-                    weight_unit = weight_sample.NetWeight.Unit
-                elif hasattr(weight_sample, 'GrossWeight'):
-                    weight_val = float(Decimal(weight_sample.GrossWeight.Value))
-                    weight_unit = weight_sample.GrossWeight.Unit
-                else:
-                    weight_val = 0.0
-                    weight_unit = 'g'
-                is_stable = getattr(weight_sample, 'Stable', True)
-            elif hasattr(reply, 'Weight'):
-                weight_val = float(Decimal(reply.Weight.Value))
-                weight_unit = reply.Weight.Unit
-                is_stable = getattr(reply.Weight, 'IsStable', True)
-            elif hasattr(reply, 'Value'):
-                weight_val = float(Decimal(reply.Value))
-                weight_unit = getattr(reply, 'Unit', 'g')
-                is_stable = getattr(reply, 'IsStable', True)
-            else:
-                # Try to extract from reply attributes
-                weight_val = float(Decimal(getattr(reply, 'WeightValue', getattr(reply, 'Value', '0'))))
-                weight_unit = getattr(reply, 'WeightUnit', getattr(reply, 'Unit', 'g'))
-                is_stable = getattr(reply, 'IsStable', True)
-            
-            # Update internal state
-            self._last_weight = weight_val
-            self._last_unit = weight_unit
-            self._is_stable = is_stable
-            
-            self.logger.info(f"Weight: {weight_val} {weight_unit}")
-            self._status = "Connected"
-            self._error_message = ""
-            
-            return weight_val, weight_unit
-            
-        except Exception as e:
-            self.logger.error(f"Get weight with unit failed: {e}")
-            self._error_message = str(e)
-            self._status = "Error"
-            return 0.0, ""
-    
-
-    
-
-    
-    def send_cmd(self, command: str) -> dict:
-        """ROS2 SendCmd action handler
-        
-        Args:
-            command: JSON string containing command and parameters
-            
-        Returns:
-            dict: Result containing success status and return_info
-        """
-        return self.execute_command_from_outer(command)
-    
-    def execute_command_from_outer(self, command: str) -> dict:
-        """Execute command from ROS2 SendCmd action
-        
-        Args:
-            command: JSON string containing command and parameters
-            
-        Returns:
-            dict: Result containing success status and return_info
-        """
-        try:
-            import json
-            # Parse JSON command
-            cmd_data = json.loads(command.replace("'", '"').replace("False", "false").replace("True", "true"))
-            
-            # Extract command name and parameters
-            cmd_name = cmd_data.get('command', '')
-            params = cmd_data.get('params', {})
-            
-            self.logger.info(f"Executing command: {cmd_name} with params: {params}")
-            
-            # Execute different commands
-            if cmd_name == 'tare':
-                immediate = params.get('immediate', False)
-                success = self.tare(immediate)
-                result = {
-                    'success': success,
-                    'return_info': f"Tare operation {'successful' if success else 'failed'}"
-                }
-                # Update instance attributes for ROS2 action system
-                self.success = result['success']
-                self.return_info = result['return_info']
-                return result
-            
-            elif cmd_name == 'zero':
-                immediate = params.get('immediate', False)
-                success = self.zero(immediate)
-                result = {
-                    'success': success,
-                    'return_info': f"Zero operation {'successful' if success else 'failed'}"
-                }
-                # Update instance attributes for ROS2 action system
-                self.success = result['success']
-                self.return_info = result['return_info']
-                return result
-            
-            elif cmd_name == 'read' or cmd_name == 'get_weight':
-                try:
-                    self.logger.info(f"Executing {cmd_name} command via ROS2...")
-                    self.logger.info(f"Current status: {self._status}")
-                    
-                    # Use get_weight to get weight value (returns float in grams)
-                    weight_grams = self.get_weight()
-                    self.logger.info(f"get_weight() returned: {weight_grams} g")
-                    
-                    # Get the original weight and unit for display
-                    original_weight = getattr(self, '_last_weight', weight_grams)
-                    original_unit = getattr(self, '_last_unit', 'g')
-                    self.logger.info(f"Original reading: {original_weight} {original_unit}")
-                    
-                    result = {
-                        'success': True,
-                        'return_info': f"Weight: {original_weight} {original_unit}"
-                    }
-                except Exception as e:
-                    self.logger.error(f"Exception in {cmd_name}: {str(e)}")
-                    self.logger.error(f"Exception type: {type(e).__name__}")
-                    import traceback
-                    self.logger.error(f"Traceback: {traceback.format_exc()}")
-                    result = {
-                        'success': False,
-                        'return_info': f"Failed to read weight: {str(e)}"
-                    }
-                # Update instance attributes for ROS2 action system
-                self.success = result['success']
-                self.return_info = result['return_info']
-                return result
-            
-
-
-            else:
-                result = {
-                    'success': False,
-                    'return_info': f"Unknown command: {cmd_name}. Available commands: tare, zero, read"
-                }
-                # Update instance attributes for ROS2 action system
-                self.success = result['success']
-                self.return_info = result['return_info']
-                return result
-                
-        except json.JSONDecodeError as e:
-            self.logger.error(f"JSON parsing failed: {e}")
-            result = {
-                'success': False,
-                'return_info': f"JSON parsing failed: {str(e)}"
-            }
-            # Update instance attributes for ROS2 action system
-            self.success = result['success']
-            self.return_info = result['return_info']
-            return result
-        except Exception as e:
-            self.logger.error(f"Command execution failed: {e}")
-            result = {
-                'success': False,
-                'return_info': f"Command execution failed: {str(e)}"
-            }
-            # Update instance attributes for ROS2 action system
-            self.success = result['success']
-            self.return_info = result['return_info']
-            return result
-    
-    def __del__(self):
-        """Cleanup when object is destroyed"""
-        self.disconnect()
-
-
-if __name__ == "__main__":
-    # Test the driver
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Mettler Toledo XPR Balance Driver Test")
-    parser.add_argument("--ip", default="192.168.1.10", help="Balance IP address")
-    parser.add_argument("--port", type=int, default=81, help="Balance port")
-    parser.add_argument("--password", default="123456", help="Balance password")
-    parser.add_argument("action", choices=["tare", "zero", "read"], 
-                       nargs="?", default="read", help="Action to perform")
-    parser.add_argument("--immediate", action="store_true", help="Use immediate mode")
-    
-    args = parser.parse_args()
-    
-    # Setup logging
-    logging.basicConfig(level=logging.INFO, 
-                       format="%(asctime)s %(levelname)s: %(message)s")
-    
-    # Create driver instance
-    balance = MettlerToledoXPR(ip=args.ip, port=args.port, password=args.password)
-    
-    try:
-        if args.action == "tare":
-            success = balance.tare(args.immediate)
-            print(f"Tare {'successful' if success else 'failed'}")
-        elif args.action == "zero":
-            success = balance.zero(args.immediate)
-            print(f"Zero {'successful' if success else 'failed'}")
-        else:  # read
-            # Perform tare first, then read weight
-            if balance.tare(args.immediate):
-                weight, unit = balance.get_weight_with_unit()
-                print(f"Weight: {weight} {unit}")
-            else:
-                print("Tare operation failed, cannot read weight")
-    
-    finally:
-        balance.disconnect()

unilabos/devices/battery/battery.json

@@ -1,29 +0,0 @@
-{
-  "nodes": [
-    {
-      "id": "NEWARE_BATTERY_TEST_SYSTEM",
-      "name": "Neware Battery Test System",
-      "parent": null,
-      "type": "device",
-      "class": "neware_battery_test_system",
-      "position": {
-        "x": 620.6111111111111,
-        "y": 171,
-        "z": 0
-      },
-      "config": {
-        "ip": "127.0.0.1",
-        "port": 502,
-        "machine_id": 1,
-        "devtype": "27",
-        "timeout": 20,
-        "size_x": 500.0,
-        "size_y": 500.0,
-        "size_z": 2000.0
-      },
-      "data": {},
-      "children": []
-    }
-  ],
-  "links": []
-}

unilabos/devices/laiyu_liquid/__init__.py

@@ -1,307 +0,0 @@
-"""
-LaiYu_Liquid 液体处理工作站集成模块
-
-该模块提供了 LaiYu_Liquid 工作站与 UniLabOS 的完整集成，包括：
-- 硬件后端和抽象接口
-- 资源定义和管理
-- 协议执行和液体传输
-- 工作台配置和布局
-
-主要组件：
-- LaiYuLiquidBackend: 硬件后端实现
-- LaiYuLiquid: 液体处理器抽象接口
-- 各种资源类：枪头架、板、容器等
-- 便捷创建函数和配置管理
-
-使用示例：
-    from unilabos.devices.laiyu_liquid import (
-        LaiYuLiquid, 
-        LaiYuLiquidBackend,
-        create_standard_deck,
-        create_tip_rack_1000ul
-    )
-    
-    # 创建后端和液体处理器
-    backend = LaiYuLiquidBackend()
-    lh = LaiYuLiquid(backend=backend)
-    
-    # 创建工作台
-    deck = create_standard_deck()
-    lh.deck = deck
-    
-    # 设置和运行
-    await lh.setup()
-"""
-
-# 版本信息
-__version__ = "1.0.0"
-__author__ = "LaiYu_Liquid Integration Team"
-__description__ = "LaiYu_Liquid 液体处理工作站 UniLabOS 集成模块"
-
-# 驱动程序导入
-from .drivers import (
-    XYZStepperController,
-    SOPAPipette,
-    MotorAxis,
-    MotorStatus,
-    SOPAConfig,
-    SOPAStatusCode,
-    StepperMotorDriver
-)
-
-# 控制器导入
-from .controllers import (
-    XYZController,
-    PipetteController,
-)
-
-# 后端导入
-from .backend.rviz_backend import (
-    LiquidHandlerRvizBackend,
-)
-
-# 资源类和创建函数导入
-from .core.laiyu_liquid_res import (
-    LaiYuLiquidDeck,
-    LaiYuLiquidContainer,
-    LaiYuLiquidTipRack
-)
-
-# 主设备类和配置
-from .core.laiyu_liquid_main import (
-    LaiYuLiquid,
-    LaiYuLiquidConfig,
-    LaiYuLiquidDeck,
-    LaiYuLiquidContainer,
-    LaiYuLiquidTipRack,
-    create_quick_setup
-)
-
-# 后端创建函数导入
-from .backend import (
-    LaiYuLiquidBackend,
-    create_laiyu_backend,
-)
-
-# 导出所有公共接口
-__all__ = [
-    # 版本信息
-    "__version__",
-    "__author__",
-    "__description__",
-    
-    # 驱动程序
-    "SOPAPipette",
-    "SOPAConfig", 
-    "StepperMotorDriver",
-    "XYZStepperController",
-    
-    # 控制器
-    "PipetteController",
-    "XYZController",
-    
-    # 后端
-    "LiquidHandlerRvizBackend",
-    
-    # 资源创建函数
-    "create_tip_rack_1000ul",
-    "create_tip_rack_200ul", 
-    "create_96_well_plate",
-    "create_deep_well_plate",
-    "create_8_tube_rack",
-    "create_standard_deck",
-    "create_waste_container",
-    "create_wash_container",
-    "create_reagent_container",
-    "load_deck_config",
-    
-    # 后端创建函数
-    "create_laiyu_backend",
-    
-    # 主要类
-    "LaiYuLiquid",
-    "LaiYuLiquidConfig", 
-    "LaiYuLiquidBackend",
-    "LaiYuLiquidDeck",
-    
-    # 工具函数
-    "get_version",
-    "get_supported_resources",
-    "create_quick_setup",
-    "validate_installation",
-    "print_module_info",
-    "setup_logging",
-]
-
-# 别名定义，为了向后兼容
-LaiYuLiquidDevice = LaiYuLiquid  # 主设备类别名
-LaiYuLiquidController = XYZController  # 控制器别名
-LaiYuLiquidDriver = XYZStepperController  # 驱动器别名
-
-# 模块级别的便捷函数
-
-def get_version() -> str:
-    """
-    获取模块版本
-    
-    Returns:
-        str: 版本号
-    """
-    return __version__
-
-
-def get_supported_resources() -> dict:
-    """
-    获取支持的资源类型
-    
-    Returns:
-        dict: 支持的资源类型字典
-    """
-    return {
-        "tip_racks": {
-            "LaiYuLiquidTipRack": LaiYuLiquidTipRack,
-        },
-        "containers": {
-            "LaiYuLiquidContainer": LaiYuLiquidContainer,
-        },
-        "decks": {
-            "LaiYuLiquidDeck": LaiYuLiquidDeck,
-        },
-        "devices": {
-            "LaiYuLiquid": LaiYuLiquid,
-        }
-    }
-
-
-def create_quick_setup() -> tuple:
-    """
-    快速创建基本设置
-    
-    Returns:
-        tuple: (backend, controllers, resources) 的元组
-    """
-    # 创建后端
-    backend = LiquidHandlerRvizBackend()
-    
-    # 创建控制器（使用默认端口进行演示）
-    pipette_controller = PipetteController(port="/dev/ttyUSB0", address=4)
-    xyz_controller = XYZController(port="/dev/ttyUSB1", auto_connect=False)
-    
-    # 创建测试资源
-    tip_rack_1000 = create_tip_rack_1000ul("tip_rack_1000")
-    tip_rack_200 = create_tip_rack_200ul("tip_rack_200")
-    well_plate = create_96_well_plate("96_well_plate")
-    
-    controllers = {
-        'pipette': pipette_controller,
-        'xyz': xyz_controller
-    }
-    
-    resources = {
-        'tip_rack_1000': tip_rack_1000,
-        'tip_rack_200': tip_rack_200,
-        'well_plate': well_plate
-    }
-    
-    return backend, controllers, resources
-
-
-def validate_installation() -> bool:
-    """
-    验证模块安装是否正确
-    
-    Returns:
-        bool: 安装是否正确
-    """
-    try:
-        # 检查核心类是否可以导入
-        from .core.laiyu_liquid_main import LaiYuLiquid, LaiYuLiquidConfig
-        from .backend import LaiYuLiquidBackend
-        from .controllers import XYZController, PipetteController
-        from .drivers import XYZStepperController, SOPAPipette
-        
-        # 尝试创建基本对象
-        config = LaiYuLiquidConfig()
-        backend = create_laiyu_backend("validation_test")
-        
-        print("模块安装验证成功")
-        return True
-        
-    except Exception as e:
-        print(f"模块安装验证失败: {e}")
-        return False
-
-
-def print_module_info():
-    """打印模块信息"""
-    print(f"LaiYu_Liquid 集成模块")
-    print(f"版本: {__version__}")
-    print(f"作者: {__author__}")
-    print(f"描述: {__description__}")
-    print(f"")
-    print(f"支持的资源类型:")
-    
-    resources = get_supported_resources()
-    for category, types in resources.items():
-        print(f"  {category}:")
-        for type_name, type_class in types.items():
-            print(f"    - {type_name}: {type_class.__name__}")
-    
-    print(f"")
-    print(f"主要功能:")
-    print(f"  - 硬件集成: LaiYuLiquidBackend")
-    print(f"  - 抽象接口: LaiYuLiquid")
-    print(f"  - 资源管理: 各种资源类和创建函数")
-    print(f"  - 协议执行: transfer_liquid 和相关函数")
-    print(f"  - 配置管理: deck.json 和加载函数")
-
-
-# 模块初始化时的检查
-def _check_dependencies():
-    """检查依赖项"""
-    try:
-        import pylabrobot
-        import asyncio
-        import json
-        import logging
-        return True
-    except ImportError as e:
-        import logging
-        logging.warning(f"缺少依赖项 {e}")
-        return False
-
-
-# 执行依赖检查
-_dependencies_ok = _check_dependencies()
-
-if not _dependencies_ok:
-    import logging
-    logging.warning("某些依赖项缺失，模块功能可能受限")
-
-
-# 模块级别的日志配置
-import logging
-
-def setup_logging(level: str = "INFO"):
-    """
-    设置模块日志
-    
-    Args:
-        level: 日志级别 (DEBUG, INFO, WARNING, ERROR)
-    """
-    logger = logging.getLogger("LaiYu_Liquid")
-    logger.setLevel(getattr(logging, level.upper()))
-    
-    if not logger.handlers:
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-    
-    return logger
-
-
-# 默认日志设置
-_logger = setup_logging()

unilabos/devices/laiyu_liquid/backend/__init__.py

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

unilabos/devices/laiyu_liquid/backend/laiyu_backend.py

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