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

扣电驱动中增加多个组装参数，elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200，更新驱动与注册表
Merge pull request #118 from h840473807/workstation_dev_YB2
2025-12-17 13:01:12 +00:00 · 2025-10-21 16:27:02 +08:00 · 2025-10-21 10:32:41 +08:00 · 2025-10-20 15:43:21 +08:00 · 2025-10-20 15:36:53 +08:00 · 2025-10-10 15:25:50 +08:00
154 changed files with 28674 additions and 25493 deletions
--- a/.conda/recipe.yaml
+++ b/.conda/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: unilabos
-  version: 0.10.7
+  version: 0.10.6

 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:
--- a/.github/workflows/conda-pack-build.yml
+++ b/.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 "=========================================="
--- a/.github/workflows/deploy-docs.yml
+++ b/.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
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,6 @@ configs/
 temp/
 output/
 unilabos_data/
-pyrightconfig.json
 ## Python

 # Byte-compiled / optimized / DLL files
--- a/15
+++ b/15
@@ -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>
--- a/README.md
+++ b/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

--- a/README_zh.md
+++ b/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)

 ## 消息格式

--- a/docs/developer_guide/add_batteryPLC.md
+++ b/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文件进行了修改，则不需要在网页端新增注册表信息。只需要运行补全注册表信息之后，上传注册表即可。
-
-
--- a/docs/developer_guide/add_yaml.md
+++ b/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`：异步执行驱动命令

 ### 如果要手动定义动作

--- a/docs/developer_guide/image_add_batteryPLC/unilab_new_yaml.png
+++ b/docs/developer_guide/image_add_batteryPLC/unilab_new_yaml.png
--- a/docs/developer_guide/image_add_batteryPLC/unilab_registry_process.png
+++ b/docs/developer_guide/image_add_batteryPLC/unilab_registry_process.png
--- a/docs/developer_guide/image_add_batteryPLC/unilab_sys_status.png
+++ b/docs/developer_guide/image_add_batteryPLC/unilab_sys_status.png
--- a/docs/developer_guide/materials_tutorial.md
+++ b/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]:
-    # 批量初始化
-```
-
-
-
-
--- a/docs/intro.md
+++ b/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
 ```

 ## 接口文档
--- a/docs/requirements.txt
+++ b/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
--- a/docs/user_guide/configuration.md
+++ b/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)

 ### 完整配置示例

--- a/docs/user_guide/image/copy_aksk.gif
+++ b/docs/user_guide/image/copy_aksk.gif
--- a/docs/user_guide/image/creatworkfollow.gif
+++ b/docs/user_guide/image/creatworkfollow.gif
--- a/docs/user_guide/image/links.png
+++ b/docs/user_guide/image/links.png
--- a/docs/user_guide/image/linksandrun.png
+++ b/docs/user_guide/image/linksandrun.png
--- a/docs/user_guide/image/material.png
+++ b/docs/user_guide/image/material.png
--- a/docs/user_guide/image/new.png
+++ b/docs/user_guide/image/new.png
--- a/docs/user_guide/launch.md
+++ b/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卡片查看详情
-* 确认其中包含参数指定的水和容量
-
-
-
-
--- a/docs/user_guide/quick_install_guide.md
+++ b/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 版本。
--- a/package.xml
+++ b/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>
--- a/recipes/msgs/recipe.yaml
+++ b/recipes/msgs/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: ros-humble-unilabos-msgs
-  version: 0.10.7
+  version: 0.10.6
 source:
  path: ../../unilabos_msgs
  target_directory: src
--- a/recipes/unilabos/recipe.yaml
+++ b/recipes/unilabos/recipe.yaml
@@ -1,6 +1,6 @@
 package:
  name: unilabos
-  version: "0.10.7"
+  version: "0.10.6"

 source:
  path: ../..
--- a/scripts/create_readme.py
+++ b/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())
--- a/scripts/create_zip_archive.py
+++ b/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()
--- a/scripts/install_unilab.bat
+++ b/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
-
--- a/scripts/install_unilab.sh
+++ b/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 ""
-
--- a/scripts/verify_installation.py
+++ b/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())
--- a/setup.py
+++ b/setup.py
@@ -4,14 +4,13 @@ package_name = 'unilabos'

 setup(
    name=package_name,
-    version='0.10.7',
+    version='0.10.6',
    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'],
--- a/test/experiments/laiyu_liquid.json
+++ b/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": []
-}
--- a/test/experiments/prcxi_9300.json
+++ b/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"
--- a/test/experiments/prcxi_9320.json
+++ b/test/experiments/prcxi_9320.json
@@ -19,7 +19,7 @@
                "host": "192.168.0.121",
                "port": 9999,
                "timeout": 10.0,
-                "axis": "Right",
+                "axis": "Left",
                "channel_num": 1,
                "setup": true,
                "debug": false,
--- a/test/experiments/test_laiyu.json
+++ b/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": []
-}
--- a/test/resources/bioyond_materials_reaction.json
+++ b/test/resources/bioyond_materials_reaction.json
@@ -1,4 +1,5 @@
-[
+{
+    "data": [
        {
            "id": "3a1c67a9-aed7-b94d-9e24-bfdf10c8baa9",
            "typeName": "烧杯",
@@ -190,4 +191,8 @@
                }
            ]
        }
-    ]
+    ],
+    "code": 1,
+    "message": "",
+    "timestamp": 1758560573511
+}
--- a/test/resources/bioyond_materials_liquidhandling_1.json
+++ b/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
-            }
-        ]
-    }
-]
--- a/test/resources/bioyond_materials_liquidhandling_2.json
+++ b/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": []
-    }
-]
--- a/test/resources/test_converter_bioyond.py
+++ b/test/resources/test_converter_bioyond.py
@@ -2,7 +2,6 @@ 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

@@ -14,63 +13,23 @@ 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",
+    "样品板": "BIOYOND_PolymerStation_6VialCarrier",
 }

-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]:
+def bioyond_materials() -> list[dict]:
    print("加载 BioYond 物料数据...")
    print(os.getcwd())
-    with open("bioyond_materials_reaction.json", "r", encoding="utf-8") as f:
-        data = json.load(f)
+    with open("bioyond_materials.json", "r", encoding="utf-8") as f:
+        data = json.load(f)["data"]
    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)
+def test_bioyond_to_plr(bioyond_materials) -> list[dict]:
    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
-    output = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=deck)
+    print("将 BioYond 物料数据转换为 PLR 格式...")
+    output = resource_bioyond_to_plr(bioyond_materials, type_mapping=type_mapping, deck=deck)
    print(deck.summary())
    print([resource.serialize() for resource in output])
    print([resource.serialize_all_state() for resource in output])
-    json.dump(deck.serialize(), open("test.json", "w", encoding="utf-8"), indent=4)
--- a/scripts/unilabos-linux-64.yaml
+++ b/scripts/unilabos-linux-64.yaml
--- a/scripts/unilabos-osx-64.yaml
+++ b/scripts/unilabos-osx-64.yaml
--- a/scripts/unilabos-osx-arm64.yaml
+++ b/scripts/unilabos-osx-arm64.yaml
--- a/scripts/unilabos-win64.yaml
+++ b/scripts/unilabos-win64.yaml
--- a/unilabos/init.py
+++ b/unilabos/init.py
@@ -1 +0,0 @@
-__version__ = "0.10.7"
--- a/unilabos/app/backend.py
+++ b/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=[],
--- a/unilabos/app/main.py
+++ b/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

@@ -227,15 +225,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 +236,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 +257,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 +278,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 +287,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 +351,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 +383,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)
--- a/unilabos/app/register.py
+++ b/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

--- a/unilabos/app/web/client.py
+++ b/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
@@ -47,7 +46,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,83 +61,6 @@ 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:
        """
        添加资源
@@ -298,7 +220,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),
        )
--- a/unilabos/app/ws_client.py
+++ b/unilabos/app/ws_client.py
@@ -19,12 +19,9 @@ import websockets
 import ssl as ssl_module
 from queue import Queue, Empty
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any, Callable, List, Set
 from urllib.parse import urlparse
 from enum import Enum
-
-from jedi.inference.gradual.typing import TypedDict
-
 from unilabos.app.model import JobAddReq
 from unilabos.ros.nodes.presets.host_node import HostNode
 from unilabos.utils.type_check import serialize_result_info
@@ -99,14 +96,6 @@ class WebSocketMessage:
    timestamp: float = field(default_factory=time.time)


-class WSResourceChatData(TypedDict):
-    uuid: str
-    device_uuid: str
-    device_id: str
-    device_old_uuid: str
-    device_old_id: str
-
-
 class DeviceActionManager:
    """设备动作管理器 - 管理每个device_action_key的任务队列"""

@@ -554,7 +543,7 @@ class MessageProcessor:
    async def _process_message(self, data: Dict[str, Any]):
        """处理收到的消息"""
        message_type = data.get("action", "")
-        message_data = data.get("data")
+        message_data = data.get("data", {})

        logger.debug(f"[MessageProcessor] Processing message: {message_type}")

@@ -567,12 +556,8 @@ class MessageProcessor:
                await self._handle_job_start(message_data)
            elif message_type == "cancel_action" or message_type == "cancel_task":
                await self._handle_cancel_action(message_data)
-            elif message_type == "add_material":
-                await self._handle_resource_tree_update(message_data, "add")
-            elif message_type == "update_material":
-                await self._handle_resource_tree_update(message_data, "update")
-            elif message_type == "remove_material":
-                await self._handle_resource_tree_update(message_data, "remove")
+            elif message_type == "":
+                return
            else:
                logger.debug(f"[MessageProcessor] Unknown message type: {message_type}")

@@ -589,7 +574,6 @@ class MessageProcessor:
    async def _handle_query_action_state(self, data: Dict[str, Any]):
        """处理query_action_state消息"""
        device_id = data.get("device_id", "")
-        device_uuid = data.get("device_uuid", "")
        action_name = data.get("action_name", "")
        task_id = data.get("task_id", "")
        job_id = data.get("job_id", "")
@@ -776,92 +760,6 @@ class MessageProcessor:
        else:
            logger.warning("[MessageProcessor] Cancel request missing both task_id and job_id")

-    async def _handle_resource_tree_update(self, resource_uuid_list: List[WSResourceChatData], action: str):
-        """处理资源树更新消息（add_material/update_material/remove_material）"""
-        if not resource_uuid_list:
-            return
-
-        # 按device_id和action分组
-        # device_action_groups: {(device_id, action): [uuid_list]}
-        device_action_groups = {}
-
-        for item in resource_uuid_list:
-            device_id = item["device_id"]
-            if not device_id:
-                device_id = "host_node"
-
-            # 特殊处理update action: 检查是否设备迁移
-            if action == "update":
-                device_old_id = item.get("device_old_id", "")
-                if not device_old_id:
-                    device_old_id = "host_node"
-
-                # 设备迁移：device_id != device_old_id
-                if device_id != device_old_id:
-                    # 给旧设备发送remove
-                    key_remove = (device_old_id, "remove")
-                    if key_remove not in device_action_groups:
-                        device_action_groups[key_remove] = []
-                    device_action_groups[key_remove].append(item["uuid"])
-
-                    # 给新设备发送add
-                    key_add = (device_id, "add")
-                    if key_add not in device_action_groups:
-                        device_action_groups[key_add] = []
-                    device_action_groups[key_add].append(item["uuid"])
-
-                    logger.info(
-                        f"[MessageProcessor] Resource migrated: {item['uuid'][:8]} from {device_old_id} to {device_id}"
-                    )
-                else:
-                    # 正常update
-                    key = (device_id, "update")
-                    if key not in device_action_groups:
-                        device_action_groups[key] = []
-                    device_action_groups[key].append(item["uuid"])
-            else:
-                # add或remove action，直接分组
-                key = (device_id, action)
-                if key not in device_action_groups:
-                    device_action_groups[key] = []
-                device_action_groups[key].append(item["uuid"])
-
-        logger.info(f"触发物料更新 {action} 分组数量: {len(device_action_groups)}, 总数量: {len(resource_uuid_list)}")
-
-        # 为每个(device_id, action)创建独立的更新线程
-        for (device_id, actual_action), items in device_action_groups.items():
-            logger.info(f"设备 {device_id} 物料更新 {actual_action} 数量: {len(items)}")
-
-            def _notify_resource_tree(dev_id, act, item_list):
-                try:
-                    host_node = HostNode.get_instance(timeout=5)
-                    if not host_node:
-                        logger.error(f"[MessageProcessor] HostNode instance not available for {act}")
-                        return
-
-                    success = host_node.notify_resource_tree_update(dev_id, act, item_list)
-
-                    if success:
-                        logger.info(
-                            f"[MessageProcessor] Resource tree {act} completed for device {dev_id}, "
-                            f"items: {len(item_list)}"
-                        )
-                    else:
-                        logger.warning(f"[MessageProcessor] Resource tree {act} failed for device {dev_id}")
-
-                except Exception as e:
-                    logger.error(f"[MessageProcessor] Error in resource tree {act} for device {dev_id}: {str(e)}")
-                    logger.error(traceback.format_exc())
-
-            # 在新线程中执行通知
-            thread = threading.Thread(
-                target=_notify_resource_tree,
-                args=(device_id, actual_action, items),
-                daemon=True,
-                name=f"ResourceTreeUpdate-{actual_action}-{device_id}",
-            )
-            thread.start()
-
    async def _send_action_state_response(
        self, device_id: str, action_name: str, task_id: str, job_id: str, typ: str, free: bool, need_more: int
    ):
@@ -1110,8 +1008,6 @@ class WebSocketClient(BaseCommunicationClient):

        # 构建WebSocket URL
        self.websocket_url = self._build_websocket_url()
-        if not self.websocket_url:
-            self.websocket_url = ""  # 默认空字符串，避免None

        # 两个核心线程
        self.message_processor = MessageProcessor(self.websocket_url, self.send_queue, self.device_manager)
--- a/unilabos/device_mesh/devices/liquid_transform_xyz/macro_device.xacro
+++ b/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>
--- a/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/base_link.STL
+++ b/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/base_link.STL
--- a/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/x_link.STL
+++ b/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/x_link.STL
--- a/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/y_link.STL
+++ b/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/y_link.STL
--- a/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/z_link.STL
+++ b/unilabos/device_mesh/devices/liquid_transform_xyz/meshes/z_link.STL
--- a/unilabos/devices/laiyu_liquid/init.py
+++ b/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()
--- a/unilabos/devices/laiyu_liquid/backend/init.py
+++ b/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']
--- a/unilabos/devices/laiyu_liquid/backend/laiyu_backend.py
+++ b/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)
--- a/unilabos/devices/laiyu_liquid/backend/rviz_backend.py
+++ b/unilabos/devices/laiyu_liquid/backend/rviz_backend.py
@@ -1,209 +0,0 @@
-      
-import json
-from typing import List, Optional, Union
-
-from pylabrobot.liquid_handling.backends.backend import (
-  LiquidHandlerBackend,
-)
-from pylabrobot.liquid_handling.standard import (
-  Drop,
-  DropTipRack,
-  MultiHeadAspirationContainer,
-  MultiHeadAspirationPlate,
-  MultiHeadDispenseContainer,
-  MultiHeadDispensePlate,
-  Pickup,
-  PickupTipRack,
-  ResourceDrop,
-  ResourceMove,
-  ResourcePickup,
-  SingleChannelAspiration,
-  SingleChannelDispense,
-)
-from pylabrobot.resources import Resource, Tip
-
-import rclpy
-from rclpy.node import Node
-from sensor_msgs.msg import JointState
-import time
-from rclpy.action import ActionClient
-from unilabos_msgs.action import SendCmd
-import re
-
-from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
-
-
-class LiquidHandlerRvizBackend(LiquidHandlerBackend):
-  """Chatter box backend for device-free testing. Prints out all operations."""
-
-  _pip_length = 5
-  _vol_length = 8
-  _resource_length = 20
-  _offset_length = 16
-  _flow_rate_length = 10
-  _blowout_length = 10
-  _lld_z_length = 10
-  _kwargs_length = 15
-  _tip_type_length = 12
-  _max_volume_length = 16
-  _fitting_depth_length = 20
-  _tip_length_length = 16
-  # _pickup_method_length = 20
-  _filter_length = 10
-
-  def __init__(self, num_channels: int = 8):
-    """Initialize a chatter box backend."""
-    super().__init__()
-    self._num_channels = num_channels
-# rclpy.init()
-    if not rclpy.ok():
-        rclpy.init()
-    self.joint_state_publisher = None
-
-  async def setup(self):
-    self.joint_state_publisher = JointStatePublisher()
-    await super().setup()
-  async def stop(self):
-    pass
-
-  def serialize(self) -> dict:
-    return {**super().serialize(), "num_channels": self.num_channels}
-
-  @property
-  def num_channels(self) -> int:
-    return self._num_channels
-
-  async def assigned_resource_callback(self, resource: Resource):
-    pass
-
-  async def unassigned_resource_callback(self, name: str):
-    pass
-
-  async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int], **backend_kwargs):
-
-    for op, channel in zip(ops, use_channels):
-      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
-      row = (
-        f"  p{channel}: "
-        f"{op.resource.name[-30:]:<{LiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{LiquidHandlerRvizBackend._offset_length}} "
-        f"{op.tip.__class__.__name__:<{LiquidHandlerRvizBackend._tip_type_length}} "
-        f"{op.tip.maximal_volume:<{LiquidHandlerRvizBackend._max_volume_length}} "
-        f"{op.tip.fitting_depth:<{LiquidHandlerRvizBackend._fitting_depth_length}} "
-        f"{op.tip.total_tip_length:<{LiquidHandlerRvizBackend._tip_length_length}} "
-        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
-        f"{'Yes' if op.tip.has_filter else 'No':<{LiquidHandlerRvizBackend._filter_length}}"
-      )
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    x = coordinate.x
-    y = coordinate.y
-    z = coordinate.z + 70
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "pick")
-    #   goback()
-
-
-
-
-  async def drop_tips(self, ops: List[Drop], use_channels: List[int], **backend_kwargs):
-
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    x = coordinate.x
-    y = coordinate.y
-    z = coordinate.z + 70
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "drop_trash")
-    #   goback()
-
-  async def aspirate(
-    self,
-    ops: List[SingleChannelAspiration],
-    use_channels: List[int],
-    **backend_kwargs,
-  ):
-    # 执行吸液操作
-    pass
-
-    for o, p in zip(ops, use_channels):
-      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
-      row = (
-        f"  p{p}: "
-        f"{o.volume:<{LiquidHandlerRvizBackend._vol_length}} "
-        f"{o.resource.name[-20:]:<{LiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{LiquidHandlerRvizBackend._offset_length}} "
-        f"{str(o.flow_rate):<{LiquidHandlerRvizBackend._flow_rate_length}} "
-        f"{str(o.blow_out_air_volume):<{LiquidHandlerRvizBackend._blowout_length}} "
-        f"{str(o.liquid_height):<{LiquidHandlerRvizBackend._lld_z_length}} "
-        # f"{o.liquids if o.liquids is not None else 'none'}"
-      )
-      for key, value in backend_kwargs.items():
-        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
-          value = "".join("T" if v else "F" for v in value)
-        if isinstance(value, list):
-          value = "".join(map(str, value))
-        row += f" {value:<15}"
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    x = coordinate.x
-    y = coordinate.y
-    z = coordinate.z + 70 
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "")
-
-
-  async def dispense(
-    self,
-    ops: List[SingleChannelDispense],
-    use_channels: List[int],
-    **backend_kwargs,
-  ):
-
-    for o, p in zip(ops, use_channels):
-      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
-      row = (
-        f"  p{p}: "
-        f"{o.volume:<{LiquidHandlerRvizBackend._vol_length}} "
-        f"{o.resource.name[-20:]:<{LiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{LiquidHandlerRvizBackend._offset_length}} "
-        f"{str(o.flow_rate):<{LiquidHandlerRvizBackend._flow_rate_length}} "
-        f"{str(o.blow_out_air_volume):<{LiquidHandlerRvizBackend._blowout_length}} "
-        f"{str(o.liquid_height):<{LiquidHandlerRvizBackend._lld_z_length}} "
-        # f"{o.liquids if o.liquids is not None else 'none'}"
-      )
-      for key, value in backend_kwargs.items():
-        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
-          value = "".join("T" if v else "F" for v in value)
-        if isinstance(value, list):
-          value = "".join(map(str, value))
-        row += f" {value:<{LiquidHandlerRvizBackend._kwargs_length}}"
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    x = coordinate.x
-    y = coordinate.y
-    z = coordinate.z + 70
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "")
-
-  async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
-    pass
-
-  async def drop_tips96(self, drop: DropTipRack, **backend_kwargs):
-    pass
-
-  async def aspirate96(
-    self, aspiration: Union[MultiHeadAspirationPlate, MultiHeadAspirationContainer]
-  ):
-    pass
-
-  async def dispense96(self, dispense: Union[MultiHeadDispensePlate, MultiHeadDispenseContainer]):
-    pass
-
-  async def pick_up_resource(self, pickup: ResourcePickup):
-    # 执行资源拾取操作
-    pass
-
-  async def move_picked_up_resource(self, move: ResourceMove):
-    # 执行资源移动操作
-    pass
-
-  async def drop_resource(self, drop: ResourceDrop):
-    # 执行资源放置操作
-    pass
-
-  def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
-    return True
-    
--- a/unilabos/devices/laiyu_liquid/config/deckconfig.json
+++ b/unilabos/devices/laiyu_liquid/config/deckconfig.json
--- a/unilabos/devices/laiyu_liquid/config/deckconfig.md
+++ b/unilabos/devices/laiyu_liquid/config/deckconfig.md
@@ -1,14 +0,0 @@
- goto 171 178 57  H1
- goto 171 117 57  A1
- goto 172 178 130
- goto 173 179 133 
-  goto 173 180 133 
-goto 173 180 138
-goto 173 180 125 （+10mm，在空的上面边缘）
-goto 173 180 130 取不到
-goto 173 180 133 取不到
-goto 173 180 135
-goto 173 180 137 取到了！！！！
-goto 173 180 131 弹出枪头 H1
-
-goto 173 117 137 A1 （+10mm，可以取到新枪头了！！！！）
--- a/unilabos/devices/laiyu_liquid/controllers/init.py
+++ b/unilabos/devices/laiyu_liquid/controllers/init.py
@@ -1,25 +0,0 @@
-"""
-LaiYu_Liquid 控制器模块
-
-该模块包含了LaiYu_Liquid液体处理工作站的高级控制器：
- 移液器控制器：提供液体处理的高级接口
- XYZ运动控制器：提供三轴运动的高级接口
-"""
-
-# 移液器控制器导入
-from .pipette_controller import PipetteController
-
-# XYZ运动控制器导入
-from .xyz_controller import XYZController
-
-__all__ = [
-    # 移液器控制器
-    "PipetteController",
-    
-    # XYZ运动控制器
-    "XYZController",
-]
-
-__version__ = "1.0.0"
-__author__ = "LaiYu_Liquid Controller Team"
-__description__ = "LaiYu_Liquid 高级控制器集合"
--- a/unilabos/devices/laiyu_liquid/controllers/pipette_controller.py
+++ b/unilabos/devices/laiyu_liquid/controllers/pipette_controller.py
--- a/unilabos/devices/laiyu_liquid/controllers/xyz_controller.py
+++ b/unilabos/devices/laiyu_liquid/controllers/xyz_controller.py
--- a/unilabos/devices/laiyu_liquid/core/init.py
+++ b/unilabos/devices/laiyu_liquid/core/init.py
@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-LaiYu液体处理设备核心模块
-
-该模块包含LaiYu液体处理设备的核心功能组件：
- LaiYu_Liquid.py: 主设备类和配置管理
- abstract_protocol.py: 抽象协议定义
- laiyu_liquid_res.py: 设备资源管理
-
-作者: UniLab团队
-版本: 2.0.0
-"""
-
-from .laiyu_liquid_main import (
-    LaiYuLiquid,
-    LaiYuLiquidConfig,
-    LaiYuLiquidBackend,
-    LaiYuLiquidDeck,
-    LaiYuLiquidContainer,
-    LaiYuLiquidTipRack,
-    create_quick_setup
-)
-
-from .laiyu_liquid_res import (
-    LaiYuLiquidDeck,
-    LaiYuLiquidContainer, 
-    LaiYuLiquidTipRack
-)
-
-__all__ = [
-    # 主设备类
-    'LaiYuLiquid',
-    'LaiYuLiquidConfig',
-    'LaiYuLiquidBackend',
-    
-    # 设备资源
-    'LaiYuLiquidDeck',
-    'LaiYuLiquidContainer',
-    'LaiYuLiquidTipRack',
-    
-    # 工具函数
-    'create_quick_setup'
-]
--- a/unilabos/devices/laiyu_liquid/core/abstract_protocol.py
+++ b/unilabos/devices/laiyu_liquid/core/abstract_protocol.py
@@ -1,529 +0,0 @@
-"""
-LaiYu_Liquid 抽象协议实现
-
-该模块提供了液体资源管理和转移的抽象协议，包括：
- MaterialResource: 液体资源管理类
- transfer_liquid: 液体转移函数
- 相关的辅助类和函数
-
-主要功能：
- 管理多孔位的液体资源
- 计算和跟踪液体体积
- 处理液体转移操作
- 提供资源状态查询
-"""
-
-import logging
-from typing import Dict, List, Optional, Union, Any, Tuple
-from dataclasses import dataclass, field
-from enum import Enum
-import uuid
-import time
-
-# pylabrobot 导入
-from pylabrobot.resources import Resource, Well, Plate
-
-logger = logging.getLogger(__name__)
-
-
-class LiquidType(Enum):
-    """液体类型枚举"""
-    WATER = "water"
-    ETHANOL = "ethanol"
-    DMSO = "dmso"
-    BUFFER = "buffer"
-    SAMPLE = "sample"
-    REAGENT = "reagent"
-    WASTE = "waste"
-    UNKNOWN = "unknown"
-
-
-@dataclass
-class LiquidInfo:
-    """液体信息类"""
-    liquid_type: LiquidType = LiquidType.UNKNOWN
-    volume: float = 0.0  # 体积 (μL)
-    concentration: Optional[float] = None  # 浓度 (mg/ml, M等)
-    ph: Optional[float] = None  # pH值
-    temperature: Optional[float] = None  # 温度 (°C)
-    viscosity: Optional[float] = None  # 粘度 (cP)
-    density: Optional[float] = None  # 密度 (g/ml)
-    description: str = ""  # 描述信息
-    
-    def __str__(self) -> str:
-        return f"{self.liquid_type.value}({self.description})"
-
-
-@dataclass
-class WellContent:
-    """孔位内容类"""
-    volume: float = 0.0  # 当前体积 (ul)
-    max_volume: float = 1000.0  # 最大容量 (ul)
-    liquid_info: LiquidInfo = field(default_factory=LiquidInfo)
-    last_updated: float = field(default_factory=time.time)
-    
-    @property
-    def is_empty(self) -> bool:
-        """检查是否为空"""
-        return self.volume <= 0.0
-    
-    @property
-    def is_full(self) -> bool:
-        """检查是否已满"""
-        return self.volume >= self.max_volume
-    
-    @property
-    def available_volume(self) -> float:
-        """可用体积"""
-        return max(0.0, self.max_volume - self.volume)
-    
-    @property
-    def fill_percentage(self) -> float:
-        """填充百分比"""
-        return (self.volume / self.max_volume) * 100.0 if self.max_volume > 0 else 0.0
-    
-    def can_add_volume(self, volume: float) -> bool:
-        """检查是否可以添加指定体积"""
-        return (self.volume + volume) <= self.max_volume
-    
-    def can_remove_volume(self, volume: float) -> bool:
-        """检查是否可以移除指定体积"""
-        return self.volume >= volume
-    
-    def add_volume(self, volume: float, liquid_info: Optional[LiquidInfo] = None) -> bool:
-        """
-        添加液体体积
-        
-        Args:
-            volume: 要添加的体积 (ul)
-            liquid_info: 液体信息
-            
-        Returns:
-            bool: 是否成功添加
-        """
-        if not self.can_add_volume(volume):
-            return False
-        
-        self.volume += volume
-        if liquid_info:
-            self.liquid_info = liquid_info
-        self.last_updated = time.time()
-        return True
-    
-    def remove_volume(self, volume: float) -> bool:
-        """
-        移除液体体积
-        
-        Args:
-            volume: 要移除的体积 (ul)
-            
-        Returns:
-            bool: 是否成功移除
-        """
-        if not self.can_remove_volume(volume):
-            return False
-        
-        self.volume -= volume
-        self.last_updated = time.time()
-        
-        # 如果完全清空，重置液体信息
-        if self.volume <= 0.0:
-            self.volume = 0.0
-            self.liquid_info = LiquidInfo()
-        
-        return True
-
-
-class MaterialResource:
-    """
-    液体资源管理类
-    
-    该类用于管理液体处理过程中的资源状态，包括：
-    - 跟踪多个孔位的液体体积和类型
-    - 计算总体积和可用体积
-    - 处理液体的添加和移除
-    - 提供资源状态查询
-    """
-    
-    def __init__(
-        self,
-        resource: Resource,
-        wells: Optional[List[Well]] = None,
-        default_max_volume: float = 1000.0
-    ):
-        """
-        初始化材料资源
-        
-        Args:
-            resource: pylabrobot 资源对象
-            wells: 孔位列表，如果为None则自动获取
-            default_max_volume: 默认最大体积 (ul)
-        """
-        self.resource = resource
-        self.resource_id = str(uuid.uuid4())
-        self.default_max_volume = default_max_volume
-        
-        # 获取孔位列表
-        if wells is None:
-            if hasattr(resource, 'get_wells'):
-                self.wells = resource.get_wells()
-            elif hasattr(resource, 'wells'):
-                self.wells = resource.wells
-            else:
-                # 如果没有孔位，创建一个虚拟孔位
-                self.wells = [resource]
-        else:
-            self.wells = wells
-        
-        # 初始化孔位内容
-        self.well_contents: Dict[str, WellContent] = {}
-        for well in self.wells:
-            well_id = self._get_well_id(well)
-            self.well_contents[well_id] = WellContent(
-                max_volume=default_max_volume
-            )
-        
-        logger.info(f"初始化材料资源: {resource.name}, 孔位数: {len(self.wells)}")
-    
-    def _get_well_id(self, well: Union[Well, Resource]) -> str:
-        """获取孔位ID"""
-        if hasattr(well, 'name'):
-            return well.name
-        else:
-            return str(id(well))
-    
-    @property
-    def name(self) -> str:
-        """资源名称"""
-        return self.resource.name
-    
-    @property
-    def total_volume(self) -> float:
-        """总液体体积"""
-        return sum(content.volume for content in self.well_contents.values())
-    
-    @property
-    def total_max_volume(self) -> float:
-        """总最大容量"""
-        return sum(content.max_volume for content in self.well_contents.values())
-    
-    @property
-    def available_volume(self) -> float:
-        """总可用体积"""
-        return sum(content.available_volume for content in self.well_contents.values())
-    
-    @property
-    def well_count(self) -> int:
-        """孔位数量"""
-        return len(self.wells)
-    
-    @property
-    def empty_wells(self) -> List[str]:
-        """空孔位列表"""
-        return [well_id for well_id, content in self.well_contents.items() 
-                if content.is_empty]
-    
-    @property
-    def full_wells(self) -> List[str]:
-        """满孔位列表"""
-        return [well_id for well_id, content in self.well_contents.items() 
-                if content.is_full]
-    
-    @property
-    def occupied_wells(self) -> List[str]:
-        """有液体的孔位列表"""
-        return [well_id for well_id, content in self.well_contents.items() 
-                if not content.is_empty]
-    
-    def get_well_content(self, well_id: str) -> Optional[WellContent]:
-        """获取指定孔位的内容"""
-        return self.well_contents.get(well_id)
-    
-    def get_well_volume(self, well_id: str) -> float:
-        """获取指定孔位的体积"""
-        content = self.get_well_content(well_id)
-        return content.volume if content else 0.0
-    
-    def set_well_volume(
-        self,
-        well_id: str,
-        volume: float,
-        liquid_info: Optional[LiquidInfo] = None
-    ) -> bool:
-        """
-        设置指定孔位的体积
-        
-        Args:
-            well_id: 孔位ID
-            volume: 体积 (ul)
-            liquid_info: 液体信息
-            
-        Returns:
-            bool: 是否成功设置
-        """
-        if well_id not in self.well_contents:
-            logger.error(f"孔位 {well_id} 不存在")
-            return False
-        
-        content = self.well_contents[well_id]
-        if volume > content.max_volume:
-            logger.error(f"体积 {volume} 超过最大容量 {content.max_volume}")
-            return False
-        
-        content.volume = max(0.0, volume)
-        if liquid_info:
-            content.liquid_info = liquid_info
-        content.last_updated = time.time()
-        
-        logger.info(f"设置孔位 {well_id} 体积: {volume}ul")
-        return True
-    
-    def add_liquid(
-        self,
-        well_id: str,
-        volume: float,
-        liquid_info: Optional[LiquidInfo] = None
-    ) -> bool:
-        """
-        向指定孔位添加液体
-        
-        Args:
-            well_id: 孔位ID
-            volume: 添加的体积 (ul)
-            liquid_info: 液体信息
-            
-        Returns:
-            bool: 是否成功添加
-        """
-        if well_id not in self.well_contents:
-            logger.error(f"孔位 {well_id} 不存在")
-            return False
-        
-        content = self.well_contents[well_id]
-        success = content.add_volume(volume, liquid_info)
-        
-        if success:
-            logger.info(f"向孔位 {well_id} 添加 {volume}ul 液体")
-        else:
-            logger.error(f"无法向孔位 {well_id} 添加 {volume}ul 液体")
-        
-        return success
-    
-    def remove_liquid(self, well_id: str, volume: float) -> bool:
-        """
-        从指定孔位移除液体
-        
-        Args:
-            well_id: 孔位ID
-            volume: 移除的体积 (ul)
-            
-        Returns:
-            bool: 是否成功移除
-        """
-        if well_id not in self.well_contents:
-            logger.error(f"孔位 {well_id} 不存在")
-            return False
-        
-        content = self.well_contents[well_id]
-        success = content.remove_volume(volume)
-        
-        if success:
-            logger.info(f"从孔位 {well_id} 移除 {volume}ul 液体")
-        else:
-            logger.error(f"无法从孔位 {well_id} 移除 {volume}ul 液体")
-        
-        return success
-    
-    def find_wells_with_volume(self, min_volume: float) -> List[str]:
-        """
-        查找具有指定最小体积的孔位
-        
-        Args:
-            min_volume: 最小体积 (ul)
-            
-        Returns:
-            List[str]: 符合条件的孔位ID列表
-        """
-        return [well_id for well_id, content in self.well_contents.items()
-                if content.volume >= min_volume]
-    
-    def find_wells_with_space(self, min_space: float) -> List[str]:
-        """
-        查找具有指定最小空间的孔位
-        
-        Args:
-            min_space: 最小空间 (ul)
-            
-        Returns:
-            List[str]: 符合条件的孔位ID列表
-        """
-        return [well_id for well_id, content in self.well_contents.items()
-                if content.available_volume >= min_space]
-    
-    def get_status_summary(self) -> Dict[str, Any]:
-        """获取资源状态摘要"""
-        return {
-            "resource_name": self.name,
-            "resource_id": self.resource_id,
-            "well_count": self.well_count,
-            "total_volume": self.total_volume,
-            "total_max_volume": self.total_max_volume,
-            "available_volume": self.available_volume,
-            "fill_percentage": (self.total_volume / self.total_max_volume) * 100.0,
-            "empty_wells": len(self.empty_wells),
-            "full_wells": len(self.full_wells),
-            "occupied_wells": len(self.occupied_wells)
-        }
-    
-    def get_detailed_status(self) -> Dict[str, Any]:
-        """获取详细状态信息"""
-        well_details = {}
-        for well_id, content in self.well_contents.items():
-            well_details[well_id] = {
-                "volume": content.volume,
-                "max_volume": content.max_volume,
-                "available_volume": content.available_volume,
-                "fill_percentage": content.fill_percentage,
-                "liquid_type": content.liquid_info.liquid_type.value,
-                "description": content.liquid_info.description,
-                "last_updated": content.last_updated
-            }
-        
-        return {
-            "summary": self.get_status_summary(),
-            "wells": well_details
-        }
-
-
-def transfer_liquid(
-    source: MaterialResource,
-    target: MaterialResource,
-    volume: float,
-    source_well_id: Optional[str] = None,
-    target_well_id: Optional[str] = None,
-    liquid_info: Optional[LiquidInfo] = None
-) -> bool:
-    """
-    在两个材料资源之间转移液体
-    
-    Args:
-        source: 源资源
-        target: 目标资源
-        volume: 转移体积 (ul)
-        source_well_id: 源孔位ID，如果为None则自动选择
-        target_well_id: 目标孔位ID，如果为None则自动选择
-        liquid_info: 液体信息
-        
-    Returns:
-        bool: 转移是否成功
-    """
-    try:
-        # 自动选择源孔位
-        if source_well_id is None:
-            available_wells = source.find_wells_with_volume(volume)
-            if not available_wells:
-                logger.error(f"源资源 {source.name} 没有足够体积的孔位")
-                return False
-            source_well_id = available_wells[0]
-        
-        # 自动选择目标孔位
-        if target_well_id is None:
-            available_wells = target.find_wells_with_space(volume)
-            if not available_wells:
-                logger.error(f"目标资源 {target.name} 没有足够空间的孔位")
-                return False
-            target_well_id = available_wells[0]
-        
-        # 检查源孔位是否有足够液体
-        if not source.get_well_content(source_well_id).can_remove_volume(volume):
-            logger.error(f"源孔位 {source_well_id} 液体不足")
-            return False
-        
-        # 检查目标孔位是否有足够空间
-        if not target.get_well_content(target_well_id).can_add_volume(volume):
-            logger.error(f"目标孔位 {target_well_id} 空间不足")
-            return False
-        
-        # 获取源液体信息
-        source_content = source.get_well_content(source_well_id)
-        transfer_liquid_info = liquid_info or source_content.liquid_info
-        
-        # 执行转移
-        if source.remove_liquid(source_well_id, volume):
-            if target.add_liquid(target_well_id, volume, transfer_liquid_info):
-                logger.info(f"成功转移 {volume}ul 液体: {source.name}[{source_well_id}] -> {target.name}[{target_well_id}]")
-                return True
-            else:
-                # 如果目标添加失败，回滚源操作
-                source.add_liquid(source_well_id, volume, source_content.liquid_info)
-                logger.error("目标添加失败，已回滚源操作")
-                return False
-        else:
-            logger.error("源移除失败")
-            return False
-    
-    except Exception as e:
-        logger.error(f"液体转移失败: {e}")
-        return False
-
-
-def create_material_resource(
-    name: str,
-    resource: Resource,
-    initial_volumes: Optional[Dict[str, float]] = None,
-    liquid_info: Optional[LiquidInfo] = None,
-    max_volume: float = 1000.0
-) -> MaterialResource:
-    """
-    创建材料资源的便捷函数
-    
-    Args:
-        name: 资源名称
-        resource: pylabrobot 资源对象
-        initial_volumes: 初始体积字典 {well_id: volume}
-        liquid_info: 液体信息
-        max_volume: 最大体积
-        
-    Returns:
-        MaterialResource: 创建的材料资源
-    """
-    material_resource = MaterialResource(
-        resource=resource,
-        default_max_volume=max_volume
-    )
-    
-    # 设置初始体积
-    if initial_volumes:
-        for well_id, volume in initial_volumes.items():
-            material_resource.set_well_volume(well_id, volume, liquid_info)
-    
-    return material_resource
-
-
-def batch_transfer_liquid(
-    transfers: List[Tuple[MaterialResource, MaterialResource, float]],
-    liquid_info: Optional[LiquidInfo] = None
-) -> List[bool]:
-    """
-    批量液体转移
-    
-    Args:
-        transfers: 转移列表 [(source, target, volume), ...]
-        liquid_info: 液体信息
-        
-    Returns:
-        List[bool]: 每个转移操作的结果
-    """
-    results = []
-    
-    for source, target, volume in transfers:
-        result = transfer_liquid(source, target, volume, liquid_info=liquid_info)
-        results.append(result)
-        
-        if not result:
-            logger.warning(f"批量转移中的操作失败: {source.name} -> {target.name}")
-    
-    success_count = sum(results)
-    logger.info(f"批量转移完成: {success_count}/{len(transfers)} 成功")
-    
-    return results
--- a/unilabos/devices/laiyu_liquid/core/laiyu_liquid_main.py
+++ b/unilabos/devices/laiyu_liquid/core/laiyu_liquid_main.py
@@ -1,881 +0,0 @@
-"""
-LaiYu_Liquid 液体处理工作站主要集成文件
-
-该模块实现了 LaiYu_Liquid 与 UniLabOS 系统的集成，提供标准化的液体处理接口。
-主要包含：
- LaiYuLiquidBackend: 硬件通信后端
- LaiYuLiquid: 主要接口类
- 相关的异常类和容器类
-"""
-
-import asyncio
-import logging
-import time
-from typing import List, Optional, Dict, Any, Union, Tuple
-from dataclasses import dataclass
-from abc import ABC, abstractmethod
-
-# 基础导入
-try:
-    from pylabrobot.resources import Deck, Plate, TipRack, Tip, Resource, Well
-    PYLABROBOT_AVAILABLE = True
-except ImportError:
-    # 如果 pylabrobot 不可用，创建基础的模拟类
-    PYLABROBOT_AVAILABLE = False
-    
-    class Resource:
-        def __init__(self, name: str):
-            self.name = name
-    
-    class Deck(Resource):
-        pass
-    
-    class Plate(Resource):
-        pass
-    
-    class TipRack(Resource):
-        pass
-    
-    class Tip(Resource):
-        pass
-    
-    class Well(Resource):
-        pass
-
-# LaiYu_Liquid 控制器导入
-try:
-    from .controllers.pipette_controller import (
-        PipetteController, TipStatus, LiquidClass, LiquidParameters
-    )
-    from .controllers.xyz_controller import (
-        XYZController, MachineConfig, CoordinateOrigin, MotorAxis
-    )
-    CONTROLLERS_AVAILABLE = True
-except ImportError:
-    CONTROLLERS_AVAILABLE = False
-    # 创建模拟的控制器类
-    class PipetteController:
-        def __init__(self, *args, **kwargs):
-            pass
-        
-        def connect(self):
-            return True
-        
-        def initialize(self):
-            return True
-    
-    class XYZController:
-        def __init__(self, *args, **kwargs):
-            pass
-        
-        def connect_device(self):
-            return True
-
-logger = logging.getLogger(__name__)
-
-
-class LaiYuLiquidError(RuntimeError):
-    """LaiYu_Liquid 设备异常"""
-    pass
-
-
-@dataclass
-class LaiYuLiquidConfig:
-    """LaiYu_Liquid 设备配置"""
-    port: str = "/dev/cu.usbserial-3130"  # RS485转USB端口
-    address: int = 1  # 设备地址
-    baudrate: int = 9600  # 波特率
-    timeout: float = 5.0  # 通信超时时间
-    
-    # 工作台尺寸
-    deck_width: float = 340.0  # 工作台宽度 (mm)
-    deck_height: float = 250.0  # 工作台高度 (mm)
-    deck_depth: float = 160.0  # 工作台深度 (mm)
-    
-    # 移液参数
-    max_volume: float = 1000.0  # 最大体积 (μL)
-    min_volume: float = 0.1  # 最小体积 (μL)
-    
-    # 运动参数
-    max_speed: float = 100.0  # 最大速度 (mm/s)
-    acceleration: float = 50.0  # 加速度 (mm/s²)
-    
-    # 安全参数
-    safe_height: float = 50.0  # 安全高度 (mm)
-    tip_pickup_depth: float = 10.0  # 吸头拾取深度 (mm)
-    liquid_detection: bool = True  # 液面检测
-    
-    # 取枪头相关参数
-    tip_pickup_speed: int = 30  # 取枪头时的移动速度 (rpm)
-    tip_pickup_acceleration: int = 500  # 取枪头时的加速度 (rpm/s)
-    tip_approach_height: float = 5.0  # 接近枪头时的高度 (mm)
-    tip_pickup_force_depth: float = 2.0  # 强制插入深度 (mm)
-    tip_pickup_retract_height: float = 20.0  # 取枪头后的回退高度 (mm)
-    
-    # 丢弃枪头相关参数
-    tip_drop_height: float = 10.0  # 丢弃枪头时的高度 (mm)
-    tip_drop_speed: int = 50  # 丢弃枪头时的移动速度 (rpm)
-    trash_position: Tuple[float, float, float] = (300.0, 200.0, 0.0)  # 垃圾桶位置 (mm)
-    
-    # 安全范围配置
-    deck_width: float = 300.0  # 工作台宽度 (mm)
-    deck_height: float = 200.0  # 工作台高度 (mm)
-    deck_depth: float = 100.0  # 工作台深度 (mm)
-    safe_height: float = 50.0  # 安全高度 (mm)
-    position_validation: bool = True  # 启用位置验证
-    emergency_stop_enabled: bool = True  # 启用紧急停止
-
-
-class LaiYuLiquidDeck:
-    """LaiYu_Liquid 工作台管理"""
-    
-    def __init__(self, config: LaiYuLiquidConfig):
-        self.config = config
-        self.resources: Dict[str, Resource] = {}
-        self.positions: Dict[str, Tuple[float, float, float]] = {}
-        
-    def add_resource(self, name: str, resource: Resource, position: Tuple[float, float, float]):
-        """添加资源到工作台"""
-        self.resources[name] = resource
-        self.positions[name] = position
-        
-    def get_resource(self, name: str) -> Optional[Resource]:
-        """获取资源"""
-        return self.resources.get(name)
-        
-    def get_position(self, name: str) -> Optional[Tuple[float, float, float]]:
-        """获取资源位置"""
-        return self.positions.get(name)
-        
-    def list_resources(self) -> List[str]:
-        """列出所有资源"""
-        return list(self.resources.keys())
-
-
-class LaiYuLiquidContainer:
-    """LaiYu_Liquid 容器类"""
-    
-    def __init__(self, name: str, size_x: float = 0, size_y: float = 0, size_z: float = 0, container_type: str = "", volume: float = 0.0, max_volume: float = 1000.0, lid_height: float = 0.0):
-        self.name = name
-        self.size_x = size_x
-        self.size_y = size_y
-        self.size_z = size_z
-        self.lid_height = lid_height
-        self.container_type = container_type
-        self.volume = volume
-        self.max_volume = max_volume
-        self.last_updated = time.time()
-        self.child_resources = {}  # 存储子资源
-        
-    @property
-    def is_empty(self) -> bool:
-        return self.volume <= 0.0
-        
-    @property
-    def is_full(self) -> bool:
-        return self.volume >= self.max_volume
-        
-    @property
-    def available_volume(self) -> float:
-        return max(0.0, self.max_volume - self.volume)
-        
-    def add_volume(self, volume: float) -> bool:
-        """添加体积"""
-        if self.volume + volume <= self.max_volume:
-            self.volume += volume
-            self.last_updated = time.time()
-            return True
-        return False
-        
-    def remove_volume(self, volume: float) -> bool:
-        """移除体积"""
-        if self.volume >= volume:
-            self.volume -= volume
-            self.last_updated = time.time()
-            return True
-        return False
-    
-    def assign_child_resource(self, resource, location=None):
-        """分配子资源 - 与 PyLabRobot 资源管理系统兼容"""
-        if hasattr(resource, 'name'):
-            self.child_resources[resource.name] = {
-                'resource': resource,
-                'location': location
-            }
-
-
-class LaiYuLiquidTipRack:
-    """LaiYu_Liquid 吸头架类"""
-    
-    def __init__(self, name: str, size_x: float = 0, size_y: float = 0, size_z: float = 0, tip_count: int = 96, tip_volume: float = 1000.0):
-        self.name = name
-        self.size_x = size_x
-        self.size_y = size_y
-        self.size_z = size_z
-        self.tip_count = tip_count
-        self.tip_volume = tip_volume
-        self.tips_available = [True] * tip_count
-        self.child_resources = {}  # 存储子资源
-        
-    @property
-    def available_tips(self) -> int:
-        return sum(self.tips_available)
-        
-    @property
-    def is_empty(self) -> bool:
-        return self.available_tips == 0
-        
-    def pick_tip(self, position: int) -> bool:
-        """拾取吸头"""
-        if 0 <= position < self.tip_count and self.tips_available[position]:
-            self.tips_available[position] = False
-            return True
-        return False
-        
-    def has_tip(self, position: int) -> bool:
-        """检查位置是否有吸头"""
-        if 0 <= position < self.tip_count:
-            return self.tips_available[position]
-        return False
-    
-    def assign_child_resource(self, resource, location=None):
-        """分配子资源到指定位置"""
-        self.child_resources[resource.name] = {
-            'resource': resource,
-            'location': location
-        }
-
-
-def get_module_info():
-    """获取模块信息"""
-    return {
-        "name": "LaiYu_Liquid",
-        "version": "1.0.0",
-        "description": "LaiYu液体处理工作站模块，提供移液器控制、XYZ轴控制和资源管理功能",
-        "author": "UniLabOS Team",
-        "capabilities": [
-            "移液器控制",
-            "XYZ轴运动控制", 
-            "吸头架管理",
-            "板和容器管理",
-            "资源位置管理"
-        ],
-        "dependencies": {
-            "required": ["serial"],
-            "optional": ["pylabrobot"]
-        }
-    }
-
-
-class LaiYuLiquidBackend:
-    """LaiYu_Liquid 硬件通信后端"""
-    
-    def __init__(self, config: LaiYuLiquidConfig, deck: Optional['LaiYuLiquidDeck'] = None):
-        self.config = config
-        self.deck = deck  # 工作台引用，用于获取资源位置信息
-        self.pipette_controller = None
-        self.xyz_controller = None
-        self.is_connected = False
-        self.is_initialized = False
-        
-        # 状态跟踪
-        self.current_position = (0.0, 0.0, 0.0)
-        self.tip_attached = False
-        self.current_volume = 0.0
-        
-    def _validate_position(self, x: float, y: float, z: float) -> bool:
-        """验证位置是否在安全范围内"""
-        try:
-            # 检查X轴范围
-            if not (0 <= x <= self.config.deck_width):
-                logger.error(f"X轴位置 {x:.2f}mm 超出范围 [0, {self.config.deck_width}]")
-                return False
-            
-            # 检查Y轴范围
-            if not (0 <= y <= self.config.deck_height):
-                logger.error(f"Y轴位置 {y:.2f}mm 超出范围 [0, {self.config.deck_height}]")
-                return False
-            
-            # 检查Z轴范围（负值表示向下，0为工作台表面）
-            if not (-self.config.deck_depth <= z <= self.config.safe_height):
-                logger.error(f"Z轴位置 {z:.2f}mm 超出安全范围 [{-self.config.deck_depth}, {self.config.safe_height}]")
-                return False
-            
-            return True
-        except Exception as e:
-            logger.error(f"位置验证失败: {e}")
-            return False
-    
-    def _check_hardware_ready(self) -> bool:
-        """检查硬件是否准备就绪"""
-        if not self.is_connected:
-            logger.error("设备未连接")
-            return False
-        
-        if CONTROLLERS_AVAILABLE:
-            if self.xyz_controller is None:
-                logger.error("XYZ控制器未初始化")
-                return False
-        
-        return True
-    
-    async def emergency_stop(self) -> bool:
-        """紧急停止所有运动"""
-        try:
-            logger.warning("执行紧急停止")
-            
-            if CONTROLLERS_AVAILABLE and self.xyz_controller:
-                # 停止XYZ控制器
-                await self.xyz_controller.stop_all_motion()
-                logger.info("XYZ控制器已停止")
-            
-            if self.pipette_controller:
-                # 停止移液器控制器
-                await self.pipette_controller.stop()
-                logger.info("移液器控制器已停止")
-            
-            return True
-        except Exception as e:
-            logger.error(f"紧急停止失败: {e}")
-            return False
-    
-    async def move_to_safe_position(self) -> bool:
-        """移动到安全位置"""
-        try:
-            if not self._check_hardware_ready():
-                return False
-            
-            safe_position = (
-                self.config.deck_width / 2,  # 工作台中心X
-                self.config.deck_height / 2,  # 工作台中心Y
-                self.config.safe_height  # 安全高度Z
-            )
-            
-            if not self._validate_position(*safe_position):
-                logger.error("安全位置无效")
-                return False
-            
-            if CONTROLLERS_AVAILABLE and self.xyz_controller:
-                await self.xyz_controller.move_to_work_coord(*safe_position)
-                self.current_position = safe_position
-                logger.info(f"已移动到安全位置: {safe_position}")
-                return True
-            else:
-                # 模拟模式
-                self.current_position = safe_position
-                logger.info("模拟移动到安全位置")
-                return True
-                
-        except Exception as e:
-            logger.error(f"移动到安全位置失败: {e}")
-            return False
-        
-    async def setup(self) -> bool:
-        """设置硬件连接"""
-        try:
-            if CONTROLLERS_AVAILABLE:
-                # 初始化移液器控制器
-                self.pipette_controller = PipetteController(
-                    port=self.config.port,
-                    address=self.config.address
-                )
-                
-                # 初始化XYZ控制器
-                machine_config = MachineConfig()
-                self.xyz_controller = XYZController(
-                    port=self.config.port,
-                    baudrate=self.config.baudrate,
-                    machine_config=machine_config
-                )
-                
-                # 连接设备
-                pipette_connected = await asyncio.to_thread(self.pipette_controller.connect)
-                xyz_connected = await asyncio.to_thread(self.xyz_controller.connect_device)
-                
-                if pipette_connected and xyz_connected:
-                    self.is_connected = True
-                    logger.info("LaiYu_Liquid 硬件连接成功")
-                    return True
-                else:
-                    logger.error("LaiYu_Liquid 硬件连接失败")
-                    return False
-            else:
-                # 模拟模式
-                logger.info("LaiYu_Liquid 运行在模拟模式")
-                self.is_connected = True
-                return True
-                
-        except Exception as e:
-            logger.error(f"LaiYu_Liquid 设置失败: {e}")
-            return False
-    
-    async def stop(self):
-        """停止设备"""
-        try:
-            if self.pipette_controller and hasattr(self.pipette_controller, 'disconnect'):
-                await asyncio.to_thread(self.pipette_controller.disconnect)
-            
-            if self.xyz_controller and hasattr(self.xyz_controller, 'disconnect'):
-                await asyncio.to_thread(self.xyz_controller.disconnect)
-                
-            self.is_connected = False
-            self.is_initialized = False
-            logger.info("LaiYu_Liquid 已停止")
-            
-        except Exception as e:
-            logger.error(f"LaiYu_Liquid 停止失败: {e}")
-    
-    async def move_to(self, x: float, y: float, z: float) -> bool:
-        """移动到指定位置"""
-        try:
-            if not self.is_connected:
-                raise LaiYuLiquidError("设备未连接")
-            
-            # 模拟移动
-            await asyncio.sleep(0.1)  # 模拟移动时间
-            self.current_position = (x, y, z)
-            logger.debug(f"移动到位置: ({x}, {y}, {z})")
-            return True
-            
-        except Exception as e:
-            logger.error(f"移动失败: {e}")
-            return False
-    
-    async def pick_up_tip(self, tip_rack: str, position: int) -> bool:
-        """拾取吸头 - 包含真正的Z轴下降控制"""
-        try:
-            # 硬件准备检查
-            if not self._check_hardware_ready():
-                return False
-                
-            if self.tip_attached:
-                logger.warning("已有吸头附着，无法拾取新吸头")
-                return False
-                
-            logger.info(f"开始从 {tip_rack} 位置 {position} 拾取吸头")
-            
-            # 获取枪头架位置信息
-            if self.deck is None:
-                logger.error("工作台未初始化")
-                return False
-                
-            tip_position = self.deck.get_position(tip_rack)
-            if tip_position is None:
-                logger.error(f"未找到枪头架 {tip_rack} 的位置信息")
-                return False
-                
-            # 计算具体枪头位置（这里简化处理，实际应根据position计算偏移）
-            tip_x, tip_y, tip_z = tip_position
-            
-            # 验证所有关键位置的安全性
-            safe_z = tip_z + self.config.tip_approach_height
-            pickup_z = tip_z - self.config.tip_pickup_force_depth
-            retract_z = tip_z + self.config.tip_pickup_retract_height
-            
-            if not (self._validate_position(tip_x, tip_y, safe_z) and 
-                    self._validate_position(tip_x, tip_y, pickup_z) and 
-                    self._validate_position(tip_x, tip_y, retract_z)):
-                logger.error("枪头拾取位置超出安全范围")
-                return False
-            
-            if CONTROLLERS_AVAILABLE and self.xyz_controller:
-                # 真实硬件控制流程
-                logger.info("使用真实XYZ控制器进行枪头拾取")
-                
-                try:
-                    # 1. 移动到枪头上方的安全位置
-                    safe_z = tip_z + self.config.tip_approach_height
-                    logger.info(f"移动到枪头上方安全位置: ({tip_x:.2f}, {tip_y:.2f}, {safe_z:.2f})")
-                    move_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord, 
-                        tip_x, tip_y, safe_z
-                    )
-                    if not move_success:
-                        logger.error("移动到枪头上方失败")
-                        return False
-                    
-                    # 2. Z轴下降到枪头位置
-                    pickup_z = tip_z - self.config.tip_pickup_force_depth
-                    logger.info(f"Z轴下降到枪头拾取位置: {pickup_z:.2f}mm")
-                    z_down_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord,
-                        tip_x, tip_y, pickup_z
-                    )
-                    if not z_down_success:
-                        logger.error("Z轴下降到枪头位置失败")
-                        return False
-                    
-                    # 3. 等待一小段时间确保枪头牢固附着
-                    await asyncio.sleep(0.2)
-                    
-                    # 4. Z轴上升到回退高度
-                    retract_z = tip_z + self.config.tip_pickup_retract_height
-                    logger.info(f"Z轴上升到回退高度: {retract_z:.2f}mm")
-                    z_up_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord,
-                        tip_x, tip_y, retract_z
-                    )
-                    if not z_up_success:
-                        logger.error("Z轴上升失败")
-                        return False
-                    
-                    # 5. 更新当前位置
-                    self.current_position = (tip_x, tip_y, retract_z)
-                    
-                except Exception as move_error:
-                    logger.error(f"枪头拾取过程中发生错误: {move_error}")
-                    # 尝试移动到安全位置
-                    if self.config.emergency_stop_enabled:
-                        await self.emergency_stop()
-                        await self.move_to_safe_position()
-                    return False
-                
-            else:
-                # 模拟模式
-                logger.info("模拟模式：执行枪头拾取动作")
-                await asyncio.sleep(1.0)  # 模拟整个拾取过程的时间
-                self.current_position = (tip_x, tip_y, tip_z + self.config.tip_pickup_retract_height)
-            
-            # 6. 标记枪头已附着
-            self.tip_attached = True
-            logger.info("吸头拾取成功")
-            return True
-            
-        except Exception as e:
-            logger.error(f"拾取吸头失败: {e}")
-            return False
-    
-    async def drop_tip(self, location: str = "trash") -> bool:
-        """丢弃吸头 - 包含真正的Z轴控制"""
-        try:
-            # 硬件准备检查
-            if not self._check_hardware_ready():
-                return False
-            
-            if not self.tip_attached:
-                logger.warning("没有吸头附着，无需丢弃")
-                return True
-            
-            logger.info(f"开始丢弃吸头到 {location}")
-            
-            # 确定丢弃位置
-            if location == "trash":
-                # 使用配置中的垃圾桶位置
-                drop_x, drop_y, drop_z = self.config.trash_position
-            else:
-                # 尝试从deck获取指定位置
-                if self.deck is None:
-                    logger.error("工作台未初始化")
-                    return False
-                    
-                drop_position = self.deck.get_position(location)
-                if drop_position is None:
-                    logger.error(f"未找到丢弃位置 {location} 的信息")
-                    return False
-                drop_x, drop_y, drop_z = drop_position
-            
-            # 验证丢弃位置的安全性
-            safe_z = drop_z + self.config.safe_height
-            drop_height_z = drop_z + self.config.tip_drop_height
-            
-            if not (self._validate_position(drop_x, drop_y, safe_z) and 
-                    self._validate_position(drop_x, drop_y, drop_height_z)):
-                logger.error("枪头丢弃位置超出安全范围")
-                return False
-            
-            if CONTROLLERS_AVAILABLE and self.xyz_controller:
-                # 真实硬件控制流程
-                logger.info("使用真实XYZ控制器进行枪头丢弃")
-                
-                try:
-                    # 1. 移动到丢弃位置上方的安全高度
-                    safe_z = drop_z + self.config.tip_drop_height
-                    logger.info(f"移动到丢弃位置上方: ({drop_x:.2f}, {drop_y:.2f}, {safe_z:.2f})")
-                    move_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord,
-                        drop_x, drop_y, safe_z
-                    )
-                    if not move_success:
-                        logger.error("移动到丢弃位置上方失败")
-                        return False
-                    
-                    # 2. Z轴下降到丢弃高度
-                    logger.info(f"Z轴下降到丢弃高度: {drop_z:.2f}mm")
-                    z_down_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord,
-                        drop_x, drop_y, drop_z
-                    )
-                    if not z_down_success:
-                        logger.error("Z轴下降到丢弃位置失败")
-                        return False
-                    
-                    # 3. 执行枪头弹出动作（如果有移液器控制器）
-                    if self.pipette_controller:
-                        try:
-                            # 发送弹出枪头命令
-                            await asyncio.to_thread(self.pipette_controller.eject_tip)
-                            logger.info("执行枪头弹出命令")
-                        except Exception as e:
-                            logger.warning(f"枪头弹出命令失败: {e}")
-                    
-                    # 4. 等待一小段时间确保枪头完全脱离
-                    await asyncio.sleep(0.3)
-                    
-                    # 5. Z轴上升到安全高度
-                    logger.info(f"Z轴上升到安全高度: {safe_z:.2f}mm")
-                    z_up_success = await asyncio.to_thread(
-                        self.xyz_controller.move_to_work_coord,
-                        drop_x, drop_y, safe_z
-                    )
-                    if not z_up_success:
-                        logger.error("Z轴上升失败")
-                        return False
-                    
-                    # 6. 更新当前位置
-                    self.current_position = (drop_x, drop_y, safe_z)
-                    
-                except Exception as drop_error:
-                    logger.error(f"枪头丢弃过程中发生错误: {drop_error}")
-                    # 尝试移动到安全位置
-                    if self.config.emergency_stop_enabled:
-                        await self.emergency_stop()
-                        await self.move_to_safe_position()
-                    return False
-                
-            else:
-                # 模拟模式
-                logger.info("模拟模式：执行枪头丢弃动作")
-                await asyncio.sleep(0.8)  # 模拟整个丢弃过程的时间
-                self.current_position = (drop_x, drop_y, drop_z + self.config.tip_drop_height)
-            
-            # 7. 标记枪头已脱离，清空体积
-            self.tip_attached = False
-            self.current_volume = 0.0
-            logger.info("吸头丢弃成功")
-            return True
-            
-        except Exception as e:
-            logger.error(f"丢弃吸头失败: {e}")
-            return False
-    
-    async def aspirate(self, volume: float, location: str) -> bool:
-        """吸取液体"""
-        try:
-            if not self.is_connected:
-                raise LaiYuLiquidError("设备未连接")
-            
-            if not self.tip_attached:
-                raise LaiYuLiquidError("没有吸头附着")
-            
-            if volume <= 0 or volume > self.config.max_volume:
-                raise LaiYuLiquidError(f"体积超出范围: {volume}")
-            
-            # 模拟吸取
-            await asyncio.sleep(0.3)
-            self.current_volume += volume
-            logger.debug(f"从 {location} 吸取 {volume} μL")
-            return True
-            
-        except Exception as e:
-            logger.error(f"吸取失败: {e}")
-            return False
-    
-    async def dispense(self, volume: float, location: str) -> bool:
-        """分配液体"""
-        try:
-            if not self.is_connected:
-                raise LaiYuLiquidError("设备未连接")
-            
-            if not self.tip_attached:
-                raise LaiYuLiquidError("没有吸头附着")
-            
-            if volume <= 0 or volume > self.current_volume:
-                raise LaiYuLiquidError(f"分配体积无效: {volume}")
-            
-            # 模拟分配
-            await asyncio.sleep(0.3)
-            self.current_volume -= volume
-            logger.debug(f"向 {location} 分配 {volume} μL")
-            return True
-            
-        except Exception as e:
-            logger.error(f"分配失败: {e}")
-            return False
-
-
-class LaiYuLiquid:
-    """LaiYu_Liquid 主要接口类"""
-    
-    def __init__(self, config: Optional[LaiYuLiquidConfig] = None, **kwargs):
-        # 如果传入了关键字参数，创建配置对象
-        if kwargs and config is None:
-            # 从kwargs中提取配置参数
-            config_params = {}
-            for key, value in kwargs.items():
-                if hasattr(LaiYuLiquidConfig, key):
-                    config_params[key] = value
-            self.config = LaiYuLiquidConfig(**config_params)
-        else:
-            self.config = config or LaiYuLiquidConfig()
-        
-        # 先创建deck，然后传递给backend
-        self.deck = LaiYuLiquidDeck(self.config)
-        self.backend = LaiYuLiquidBackend(self.config, self.deck)
-        self.is_setup = False
-    
-    @property
-    def current_position(self) -> Tuple[float, float, float]:
-        """获取当前位置"""
-        return self.backend.current_position
-    
-    @property
-    def current_volume(self) -> float:
-        """获取当前体积"""
-        return self.backend.current_volume
-    
-    @property
-    def is_connected(self) -> bool:
-        """获取连接状态"""
-        return self.backend.is_connected
-    
-    @property
-    def is_initialized(self) -> bool:
-        """获取初始化状态"""
-        return self.backend.is_initialized
-    
-    @property
-    def tip_attached(self) -> bool:
-        """获取吸头附着状态"""
-        return self.backend.tip_attached
-        
-    async def setup(self) -> bool:
-        """设置液体处理器"""
-        try:
-            success = await self.backend.setup()
-            if success:
-                self.is_setup = True
-                logger.info("LaiYu_Liquid 设置完成")
-            return success
-        except Exception as e:
-            logger.error(f"LaiYu_Liquid 设置失败: {e}")
-            return False
-    
-    async def stop(self):
-        """停止液体处理器"""
-        await self.backend.stop()
-        self.is_setup = False
-    
-    async def transfer(self, source: str, target: str, volume: float, 
-                      tip_rack: str = "tip_rack_1", tip_position: int = 0) -> bool:
-        """液体转移"""
-        try:
-            if not self.is_setup:
-                raise LaiYuLiquidError("设备未设置")
-            
-            # 获取源和目标位置
-            source_pos = self.deck.get_position(source)
-            target_pos = self.deck.get_position(target)
-            tip_pos = self.deck.get_position(tip_rack)
-            
-            if not all([source_pos, target_pos, tip_pos]):
-                raise LaiYuLiquidError("位置信息不完整")
-            
-            # 执行转移步骤
-            steps = [
-                ("移动到吸头架", self.backend.move_to(*tip_pos)),
-                ("拾取吸头", self.backend.pick_up_tip(tip_rack, tip_position)),
-                ("移动到源位置", self.backend.move_to(*source_pos)),
-                ("吸取液体", self.backend.aspirate(volume, source)),
-                ("移动到目标位置", self.backend.move_to(*target_pos)),
-                ("分配液体", self.backend.dispense(volume, target)),
-                ("丢弃吸头", self.backend.drop_tip())
-            ]
-            
-            for step_name, step_coro in steps:
-                logger.debug(f"执行步骤: {step_name}")
-                success = await step_coro
-                if not success:
-                    raise LaiYuLiquidError(f"步骤失败: {step_name}")
-            
-            logger.info(f"液体转移完成: {source} -> {target}, {volume} μL")
-            return True
-            
-        except Exception as e:
-            logger.error(f"液体转移失败: {e}")
-            return False
-    
-    def add_resource(self, name: str, resource_type: str, position: Tuple[float, float, float]):
-        """添加资源到工作台"""
-        if resource_type == "plate":
-            resource = Plate(name)
-        elif resource_type == "tip_rack":
-            resource = TipRack(name)
-        else:
-            resource = Resource(name)
-        
-        self.deck.add_resource(name, resource, position)
-    
-    def get_status(self) -> Dict[str, Any]:
-        """获取设备状态"""
-        return {
-            "connected": self.backend.is_connected,
-            "setup": self.is_setup,
-            "current_position": self.backend.current_position,
-            "tip_attached": self.backend.tip_attached,
-            "current_volume": self.backend.current_volume,
-            "resources": self.deck.list_resources()
-        }
-
-
-def create_quick_setup() -> LaiYuLiquidDeck:
-    """
-    创建快速设置的LaiYu液体处理工作站
-    
-    Returns:
-        LaiYuLiquidDeck: 配置好的工作台实例
-    """
-    # 创建默认配置
-    config = LaiYuLiquidConfig()
-    
-    # 创建工作台
-    deck = LaiYuLiquidDeck(config)
-    
-    # 导入资源创建函数
-    try:
-        from .laiyu_liquid_res import (
-            create_tip_rack_1000ul,
-            create_tip_rack_200ul,
-            create_96_well_plate,
-            create_waste_container
-        )
-        
-        # 添加基本资源
-        tip_rack_1000 = create_tip_rack_1000ul("tip_rack_1000")
-        tip_rack_200 = create_tip_rack_200ul("tip_rack_200")
-        plate_96 = create_96_well_plate("plate_96")
-        waste = create_waste_container("waste")
-        
-        # 添加到工作台
-        deck.add_resource("tip_rack_1000", tip_rack_1000, (50, 50, 0))
-        deck.add_resource("tip_rack_200", tip_rack_200, (150, 50, 0))
-        deck.add_resource("plate_96", plate_96, (250, 50, 0))
-        deck.add_resource("waste", waste, (50, 150, 0))
-        
-    except ImportError:
-        # 如果资源模块不可用，创建空的工作台
-        logger.warning("资源模块不可用，创建空的工作台")
-    
-    return deck
-
-
-__all__ = [
-    "LaiYuLiquid",
-    "LaiYuLiquidBackend", 
-    "LaiYuLiquidConfig",
-    "LaiYuLiquidDeck",
-    "LaiYuLiquidContainer",
-    "LaiYuLiquidTipRack",
-    "LaiYuLiquidError",
-    "create_quick_setup",
-    "get_module_info"
-]
--- a/unilabos/devices/laiyu_liquid/core/laiyu_liquid_res.py
+++ b/unilabos/devices/laiyu_liquid/core/laiyu_liquid_res.py
@@ -1,954 +0,0 @@
-"""
-LaiYu_Liquid 资源定义模块
-
-该模块提供了 LaiYu_Liquid 工作站专用的资源定义函数，包括：
- 各种规格的枪头架
- 不同类型的板和容器
- 特殊功能位置
- 资源创建的便捷函数
-
-所有资源都基于 deck.json 中的配置参数创建。
-"""
-
-import json
-import os
-from typing import Dict, List, Optional, Tuple, Any
-from pathlib import Path
-
-# PyLabRobot 资源导入
-try:
-    from pylabrobot.resources import (
-        Resource, Deck, Plate, TipRack, Container, Tip,
-        Coordinate
-    )
-    from pylabrobot.resources.tip_rack import TipSpot
-    from pylabrobot.resources.well import Well as PlateWell
-    PYLABROBOT_AVAILABLE = True
-except ImportError:
-    # 如果 PyLabRobot 不可用，创建模拟类
-    PYLABROBOT_AVAILABLE = False
-    
-    class Resource:
-        def __init__(self, name: str):
-            self.name = name
-    
-    class Deck(Resource):
-        pass
-    
-    class Plate(Resource):
-        pass
-    
-    class TipRack(Resource):
-        pass
-    
-    class Container(Resource):
-        pass
-    
-    class Tip(Resource):
-        pass
-    
-    class TipSpot(Resource):
-        def __init__(self, name: str, **kwargs):
-            super().__init__(name)
-            # 忽略其他参数
-    
-    class PlateWell(Resource):
-        pass
-    
-    class Coordinate:
-        def __init__(self, x: float, y: float, z: float):
-            self.x = x
-            self.y = y
-            self.z = z
-
-# 本地导入
-from .laiyu_liquid_main import LaiYuLiquidDeck, LaiYuLiquidContainer, LaiYuLiquidTipRack
-
-
-def load_deck_config() -> Dict[str, Any]:
-    """
-    加载工作台配置文件
-    
-    Returns:
-        Dict[str, Any]: 配置字典
-    """
-    # 优先使用最新的deckconfig.json文件
-    config_path = Path(__file__).parent / "controllers" / "deckconfig.json"
-    
-    # 如果最新配置文件不存在，回退到旧配置文件
-    if not config_path.exists():
-        config_path = Path(__file__).parent / "config" / "deck.json"
-    
-    try:
-        with open(config_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        # 如果找不到配置文件，返回默认配置
-        return {
-            "name": "LaiYu_Liquid_Deck",
-            "size_x": 340.0,  
-            "size_y": 250.0,
-            "size_z": 160.0
-        }
-
-
-# 加载配置
-DECK_CONFIG = load_deck_config()
-
-
-class LaiYuTipRack1000(LaiYuLiquidTipRack):
-    """1000μL 枪头架"""
-    
-    def __init__(self, name: str):
-        """
-        初始化1000μL枪头架
-        
-        Args:
-            name: 枪头架名称
-        """
-        super().__init__(
-            name=name,
-            size_x=127.76,
-            size_y=85.48,
-            size_z=30.0,
-            tip_count=96,
-            tip_volume=1000.0
-        )
-        
-        # 创建枪头位置
-        self._create_tip_spots(
-            tip_count=96,
-            tip_spacing=9.0,
-            tip_type="1000ul"
-        )
-    
-    def _create_tip_spots(self, tip_count: int, tip_spacing: float, tip_type: str):
-        """
-        创建枪头位置 - 从配置文件中读取绝对坐标
-        
-        Args:
-            tip_count: 枪头数量
-            tip_spacing: 枪头间距
-            tip_type: 枪头类型
-        """
-        # 从配置文件中获取枪头架的孔位信息
-        config = DECK_CONFIG
-        tip_module = None
-        
-        # 查找枪头架模块
-        for module in config.get("children", []):
-            if module.get("type") == "tip_rack":
-                tip_module = module
-                break
-        
-        if not tip_module:
-            # 如果配置文件中没有找到，使用默认的相对坐标计算
-            rows = 8
-            cols = 12
-            
-            for row in range(rows):
-                for col in range(cols):
-                    spot_name = f"{chr(65 + row)}{col + 1:02d}"
-                    x = col * tip_spacing + tip_spacing / 2
-                    y = row * tip_spacing + tip_spacing / 2
-                    
-                    # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
-                    if PYLABROBOT_AVAILABLE:
-                        # PyLabRobot的Tip需要特定参数
-                        tip = Tip(
-                            has_filter=False,
-                            total_tip_length=95.0,  # 1000ul枪头长度
-                            maximal_volume=1000.0,  # 最大体积
-                            fitting_depth=8.0       # 安装深度
-                        )
-                    else:
-                        # 模拟类只需要name
-                        tip = Tip(name=f"tip_{spot_name}")
-                    
-                    # 创建枪头位置
-                    if PYLABROBOT_AVAILABLE:
-                        # PyLabRobot的TipSpot需要特定参数
-                        tip_spot = TipSpot(
-                            name=spot_name,
-                            size_x=9.0,  # 枪头位置宽度
-                            size_y=9.0,  # 枪头位置深度
-                            size_z=95.0,  # 枪头位置高度
-                            make_tip=lambda: tip  # 创建枪头的函数
-                        )
-                    else:
-                        # 模拟类只需要name
-                        tip_spot = TipSpot(name=spot_name)
-                    
-                    # 将吸头位置分配到吸头架
-                    self.assign_child_resource(
-                        tip_spot,
-                        location=Coordinate(x, y, 0)
-                    )
-            return
-        
-        # 使用配置文件中的绝对坐标
-        module_position = tip_module.get("position", {"x": 0, "y": 0, "z": 0})
-        
-        for well_config in tip_module.get("wells", []):
-            spot_name = well_config["id"]
-            well_pos = well_config["position"]
-            
-            # 计算相对于模块的坐标（绝对坐标减去模块位置）
-            relative_x = well_pos["x"] - module_position["x"]
-            relative_y = well_pos["y"] - module_position["y"]
-            relative_z = well_pos["z"] - module_position["z"]
-            
-            # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
-            if PYLABROBOT_AVAILABLE:
-                # PyLabRobot的Tip需要特定参数
-                tip = Tip(
-                    has_filter=False,
-                    total_tip_length=95.0,  # 1000ul枪头长度
-                    maximal_volume=1000.0,  # 最大体积
-                    fitting_depth=8.0       # 安装深度
-                )
-            else:
-                # 模拟类只需要name
-                tip = Tip(name=f"tip_{spot_name}")
-            
-            # 创建枪头位置
-            if PYLABROBOT_AVAILABLE:
-                # PyLabRobot的TipSpot需要特定参数
-                tip_spot = TipSpot(
-                    name=spot_name,
-                    size_x=well_config.get("diameter", 9.0),  # 使用配置中的直径
-                    size_y=well_config.get("diameter", 9.0),
-                    size_z=well_config.get("depth", 95.0),    # 使用配置中的深度
-                    make_tip=lambda: tip  # 创建枪头的函数
-                )
-            else:
-                # 模拟类只需要name
-                tip_spot = TipSpot(name=spot_name)
-            
-            # 将吸头位置分配到吸头架
-            self.assign_child_resource(
-                tip_spot,
-                location=Coordinate(relative_x, relative_y, relative_z)
-            )
-            
-            # 注意：在PyLabRobot中，Tip不是Resource，不需要分配给TipSpot
-            # TipSpot的make_tip函数会在需要时创建Tip
-
-
-class LaiYuTipRack200(LaiYuLiquidTipRack):
-    """200μL 枪头架"""
-    
-    def __init__(self, name: str):
-        """
-        初始化200μL枪头架
-        
-        Args:
-            name: 枪头架名称
-        """
-        super().__init__(
-            name=name,
-            size_x=127.76,
-            size_y=85.48,
-            size_z=30.0,
-            tip_count=96,
-            tip_volume=200.0
-        )
-        
-        # 创建枪头位置
-        self._create_tip_spots(
-            tip_count=96,
-            tip_spacing=9.0,
-            tip_type="200ul"
-        )
-    
-    def _create_tip_spots(self, tip_count: int, tip_spacing: float, tip_type: str):
-        """
-        创建枪头位置
-        
-        Args:
-            tip_count: 枪头数量
-            tip_spacing: 枪头间距
-            tip_type: 枪头类型
-        """
-        rows = 8
-        cols = 12
-        
-        for row in range(rows):
-            for col in range(cols):
-                spot_name = f"{chr(65 + row)}{col + 1:02d}"
-                x = col * tip_spacing + tip_spacing / 2
-                y = row * tip_spacing + tip_spacing / 2
-                
-                # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
-                if PYLABROBOT_AVAILABLE:
-                    # PyLabRobot的Tip需要特定参数
-                    tip = Tip(
-                        has_filter=False,
-                        total_tip_length=72.0,  # 200ul枪头长度
-                        maximal_volume=200.0,   # 最大体积
-                        fitting_depth=8.0       # 安装深度
-                    )
-                else:
-                    # 模拟类只需要name
-                    tip = Tip(name=f"tip_{spot_name}")
-                
-                # 创建枪头位置
-                if PYLABROBOT_AVAILABLE:
-                    # PyLabRobot的TipSpot需要特定参数
-                    tip_spot = TipSpot(
-                        name=spot_name,
-                        size_x=9.0,  # 枪头位置宽度
-                        size_y=9.0,  # 枪头位置深度
-                        size_z=72.0,  # 枪头位置高度
-                        make_tip=lambda: tip  # 创建枪头的函数
-                    )
-                else:
-                    # 模拟类只需要name
-                    tip_spot = TipSpot(name=spot_name)
-                
-                # 将吸头位置分配到吸头架
-                self.assign_child_resource(
-                    tip_spot,
-                    location=Coordinate(x, y, 0)
-                )
-                
-                # 注意：在PyLabRobot中，Tip不是Resource，不需要分配给TipSpot
-                # TipSpot的make_tip函数会在需要时创建Tip
-
-
-class LaiYu96WellPlate(LaiYuLiquidContainer):
-    """96孔板"""
-    
-    def __init__(self, name: str, lid_height: float = 0.0):
-        """
-        初始化96孔板
-        
-        Args:
-            name: 板名称
-            lid_height: 盖子高度
-        """
-        super().__init__(
-            name=name,
-            size_x=127.76,
-            size_y=85.48,
-            size_z=14.22,
-            container_type="96_well_plate",
-            volume=0.0,
-            max_volume=200.0,
-            lid_height=lid_height
-        )
-        
-        # 创建孔位
-        self._create_wells(
-            well_count=96,
-            well_volume=200.0,
-            well_spacing=9.0
-        )
-    
-    def get_size_z(self) -> float:
-        """获取孔位深度"""
-        return 10.0  # 96孔板孔位深度
-    
-    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
-        """
-        创建孔位 - 从配置文件中读取绝对坐标
-        
-        Args:
-            well_count: 孔位数量
-            well_volume: 孔位体积
-            well_spacing: 孔位间距
-        """
-        # 从配置文件中获取96孔板的孔位信息
-        config = DECK_CONFIG
-        plate_module = None
-        
-        # 查找96孔板模块
-        for module in config.get("children", []):
-            if module.get("type") == "96_well_plate":
-                plate_module = module
-                break
-        
-        if not plate_module:
-            # 如果配置文件中没有找到，使用默认的相对坐标计算
-            rows = 8
-            cols = 12
-            
-            for row in range(rows):
-                for col in range(cols):
-                    well_name = f"{chr(65 + row)}{col + 1:02d}"
-                    x = col * well_spacing + well_spacing / 2
-                    y = row * well_spacing + well_spacing / 2
-                    
-                    # 创建孔位
-                    well = PlateWell(
-                        name=well_name,
-                        size_x=well_spacing * 0.8,
-                        size_y=well_spacing * 0.8,
-                        size_z=self.get_size_z(),
-                        max_volume=well_volume
-                    )
-                    
-                    # 添加到板
-                    self.assign_child_resource(
-                        well,
-                        location=Coordinate(x, y, 0)
-                    )
-            return
-        
-        # 使用配置文件中的绝对坐标
-        module_position = plate_module.get("position", {"x": 0, "y": 0, "z": 0})
-        
-        for well_config in plate_module.get("wells", []):
-            well_name = well_config["id"]
-            well_pos = well_config["position"]
-            
-            # 计算相对于模块的坐标（绝对坐标减去模块位置）
-            relative_x = well_pos["x"] - module_position["x"]
-            relative_y = well_pos["y"] - module_position["y"]
-            relative_z = well_pos["z"] - module_position["z"]
-            
-            # 创建孔位
-            well = PlateWell(
-                name=well_name,
-                size_x=well_config.get("diameter", 8.2) * 0.8,  # 使用配置中的直径
-                size_y=well_config.get("diameter", 8.2) * 0.8,
-                size_z=well_config.get("depth", self.get_size_z()),
-                max_volume=well_config.get("volume", well_volume)
-            )
-            
-            # 添加到板
-            self.assign_child_resource(
-                well,
-                location=Coordinate(relative_x, relative_y, relative_z)
-            )
-
-
-class LaiYuDeepWellPlate(LaiYuLiquidContainer):
-    """深孔板"""
-    
-    def __init__(self, name: str, lid_height: float = 0.0):
-        """
-        初始化深孔板
-        
-        Args:
-            name: 板名称
-            lid_height: 盖子高度
-        """
-        super().__init__(
-            name=name,
-            size_x=127.76,
-            size_y=85.48,
-            size_z=41.3,
-            container_type="deep_well_plate",
-            volume=0.0,
-            max_volume=2000.0,
-            lid_height=lid_height
-        )
-        
-        # 创建孔位
-        self._create_wells(
-            well_count=96,
-            well_volume=2000.0,
-            well_spacing=9.0
-        )
-    
-    def get_size_z(self) -> float:
-        """获取孔位深度"""
-        return 35.0  # 深孔板孔位深度
-    
-    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
-        """
-        创建孔位 - 从配置文件中读取绝对坐标
-        
-        Args:
-            well_count: 孔位数量
-            well_volume: 孔位体积
-            well_spacing: 孔位间距
-        """
-        # 从配置文件中获取深孔板的孔位信息
-        config = DECK_CONFIG
-        plate_module = None
-        
-        # 查找深孔板模块（通常是第二个96孔板模块）
-        plate_modules = []
-        for module in config.get("children", []):
-            if module.get("type") == "96_well_plate":
-                plate_modules.append(module)
-        
-        # 如果有多个96孔板模块，选择第二个作为深孔板
-        if len(plate_modules) > 1:
-            plate_module = plate_modules[1]
-        elif len(plate_modules) == 1:
-            plate_module = plate_modules[0]
-        
-        if not plate_module:
-            # 如果配置文件中没有找到，使用默认的相对坐标计算
-            rows = 8
-            cols = 12
-            
-            for row in range(rows):
-                for col in range(cols):
-                    well_name = f"{chr(65 + row)}{col + 1:02d}"
-                    x = col * well_spacing + well_spacing / 2
-                    y = row * well_spacing + well_spacing / 2
-                    
-                    # 创建孔位
-                    well = PlateWell(
-                        name=well_name,
-                        size_x=well_spacing * 0.8,
-                        size_y=well_spacing * 0.8,
-                        size_z=self.get_size_z(),
-                        max_volume=well_volume
-                    )
-                    
-                    # 添加到板
-                    self.assign_child_resource(
-                        well,
-                        location=Coordinate(x, y, 0)
-                    )
-            return
-        
-        # 使用配置文件中的绝对坐标
-        module_position = plate_module.get("position", {"x": 0, "y": 0, "z": 0})
-        
-        for well_config in plate_module.get("wells", []):
-            well_name = well_config["id"]
-            well_pos = well_config["position"]
-            
-            # 计算相对于模块的坐标（绝对坐标减去模块位置）
-            relative_x = well_pos["x"] - module_position["x"]
-            relative_y = well_pos["y"] - module_position["y"]
-            relative_z = well_pos["z"] - module_position["z"]
-            
-            # 创建孔位
-            well = PlateWell(
-                name=well_name,
-                size_x=well_config.get("diameter", 8.2) * 0.8,  # 使用配置中的直径
-                size_y=well_config.get("diameter", 8.2) * 0.8,
-                size_z=well_config.get("depth", self.get_size_z()),
-                max_volume=well_config.get("volume", well_volume)
-            )
-            
-            # 添加到板
-            self.assign_child_resource(
-                well,
-                location=Coordinate(relative_x, relative_y, relative_z)
-            )
-
-
-class LaiYuWasteContainer(Container):
-    """废液容器"""
-    
-    def __init__(self, name: str):
-        """
-        初始化废液容器
-        
-        Args:
-            name: 容器名称
-        """
-        super().__init__(
-            name=name,
-            size_x=100.0,
-            size_y=100.0,
-            size_z=50.0,
-            max_volume=5000.0
-        )
-
-
-class LaiYuWashContainer(Container):
-    """清洗容器"""
-    
-    def __init__(self, name: str):
-        """
-        初始化清洗容器
-        
-        Args:
-            name: 容器名称
-        """
-        super().__init__(
-            name=name,
-            size_x=100.0,
-            size_y=100.0,
-            size_z=50.0,
-            max_volume=5000.0
-        )
-
-
-class LaiYuReagentContainer(Container):
-    """试剂容器"""
-    
-    def __init__(self, name: str):
-        """
-        初始化试剂容器
-        
-        Args:
-            name: 容器名称
-        """
-        super().__init__(
-            name=name,
-            size_x=50.0,
-            size_y=50.0,
-            size_z=100.0,
-            max_volume=2000.0
-        )
-
-
-class LaiYu8TubeRack(LaiYuLiquidContainer):
-    """8管试管架"""
-    
-    def __init__(self, name: str):
-        """
-        初始化8管试管架
-        
-        Args:
-            name: 试管架名称
-        """
-        super().__init__(
-            name=name,
-            size_x=151.0,
-            size_y=75.0,
-            size_z=75.0,
-            container_type="tube_rack",
-            volume=0.0,
-            max_volume=77000.0
-        )
-        
-        # 创建孔位
-        self._create_wells(
-            well_count=8,
-            well_volume=77000.0,
-            well_spacing=35.0
-        )
-    
-    def get_size_z(self) -> float:
-        """获取孔位深度"""
-        return 117.0  # 试管深度
-    
-    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
-        """
-        创建孔位 - 从配置文件中读取绝对坐标
-        
-        Args:
-            well_count: 孔位数量
-            well_volume: 孔位体积
-            well_spacing: 孔位间距
-        """
-        # 从配置文件中获取8管试管架的孔位信息
-        config = DECK_CONFIG
-        tube_module = None
-        
-        # 查找8管试管架模块
-        for module in config.get("children", []):
-            if module.get("type") == "tube_rack":
-                tube_module = module
-                break
-        
-        if not tube_module:
-            # 如果配置文件中没有找到，使用默认的相对坐标计算
-            rows = 2
-            cols = 4
-            
-            for row in range(rows):
-                for col in range(cols):
-                    well_name = f"{chr(65 + row)}{col + 1}"
-                    x = col * well_spacing + well_spacing / 2
-                    y = row * well_spacing + well_spacing / 2
-                    
-                    # 创建孔位
-                    well = PlateWell(
-                        name=well_name,
-                        size_x=29.0,
-                        size_y=29.0,
-                        size_z=self.get_size_z(),
-                        max_volume=well_volume
-                    )
-                    
-                    # 添加到试管架
-                    self.assign_child_resource(
-                        well,
-                        location=Coordinate(x, y, 0)
-                    )
-            return
-        
-        # 使用配置文件中的绝对坐标
-        module_position = tube_module.get("position", {"x": 0, "y": 0, "z": 0})
-        
-        for well_config in tube_module.get("wells", []):
-            well_name = well_config["id"]
-            well_pos = well_config["position"]
-            
-            # 计算相对于模块的坐标（绝对坐标减去模块位置）
-            relative_x = well_pos["x"] - module_position["x"]
-            relative_y = well_pos["y"] - module_position["y"]
-            relative_z = well_pos["z"] - module_position["z"]
-            
-            # 创建孔位
-            well = PlateWell(
-                name=well_name,
-                size_x=well_config.get("diameter", 29.0),
-                size_y=well_config.get("diameter", 29.0),
-                size_z=well_config.get("depth", self.get_size_z()),
-                max_volume=well_config.get("volume", well_volume)
-            )
-            
-            # 添加到试管架
-            self.assign_child_resource(
-                well,
-                location=Coordinate(relative_x, relative_y, relative_z)
-            )
-
-
-class LaiYuTipDisposal(Resource):
-    """枪头废料位置"""
-    
-    def __init__(self, name: str):
-        """
-        初始化枪头废料位置
-        
-        Args:
-            name: 位置名称
-        """
-        super().__init__(
-            name=name,
-            size_x=100.0,
-            size_y=100.0,
-            size_z=50.0
-        )
-
-
-class LaiYuMaintenancePosition(Resource):
-    """维护位置"""
-    
-    def __init__(self, name: str):
-        """
-        初始化维护位置
-        
-        Args:
-            name: 位置名称
-        """
-        super().__init__(
-            name=name,
-            size_x=50.0,
-            size_y=50.0,
-            size_z=100.0
-        )
-
-
-# 资源创建函数
-def create_tip_rack_1000ul(name: str = "tip_rack_1000ul") -> LaiYuTipRack1000:
-    """
-    创建1000μL枪头架
-    
-    Args:
-        name: 枪头架名称
-        
-    Returns:
-        LaiYuTipRack1000: 1000μL枪头架实例
-    """
-    return LaiYuTipRack1000(name)
-
-
-def create_tip_rack_200ul(name: str = "tip_rack_200ul") -> LaiYuTipRack200:
-    """
-    创建200μL枪头架
-    
-    Args:
-        name: 枪头架名称
-        
-    Returns:
-        LaiYuTipRack200: 200μL枪头架实例
-    """
-    return LaiYuTipRack200(name)
-
-
-def create_96_well_plate(name: str = "96_well_plate", lid_height: float = 0.0) -> LaiYu96WellPlate:
-    """
-    创建96孔板
-    
-    Args:
-        name: 板名称
-        lid_height: 盖子高度
-        
-    Returns:
-        LaiYu96WellPlate: 96孔板实例
-    """
-    return LaiYu96WellPlate(name, lid_height)
-
-
-def create_deep_well_plate(name: str = "deep_well_plate", lid_height: float = 0.0) -> LaiYuDeepWellPlate:
-    """
-    创建深孔板
-    
-    Args:
-        name: 板名称
-        lid_height: 盖子高度
-        
-    Returns:
-        LaiYuDeepWellPlate: 深孔板实例
-    """
-    return LaiYuDeepWellPlate(name, lid_height)
-
-
-def create_8_tube_rack(name: str = "8_tube_rack") -> LaiYu8TubeRack:
-    """
-    创建8管试管架
-    
-    Args:
-        name: 试管架名称
-        
-    Returns:
-        LaiYu8TubeRack: 8管试管架实例
-    """
-    return LaiYu8TubeRack(name)
-
-
-def create_waste_container(name: str = "waste_container") -> LaiYuWasteContainer:
-    """
-    创建废液容器
-    
-    Args:
-        name: 容器名称
-        
-    Returns:
-        LaiYuWasteContainer: 废液容器实例
-    """
-    return LaiYuWasteContainer(name)
-
-
-def create_wash_container(name: str = "wash_container") -> LaiYuWashContainer:
-    """
-    创建清洗容器
-    
-    Args:
-        name: 容器名称
-        
-    Returns:
-        LaiYuWashContainer: 清洗容器实例
-    """
-    return LaiYuWashContainer(name)
-
-
-def create_reagent_container(name: str = "reagent_container") -> LaiYuReagentContainer:
-    """
-    创建试剂容器
-    
-    Args:
-        name: 容器名称
-        
-    Returns:
-        LaiYuReagentContainer: 试剂容器实例
-    """
-    return LaiYuReagentContainer(name)
-
-
-def create_tip_disposal(name: str = "tip_disposal") -> LaiYuTipDisposal:
-    """
-    创建枪头废料位置
-    
-    Args:
-        name: 位置名称
-        
-    Returns:
-        LaiYuTipDisposal: 枪头废料位置实例
-    """
-    return LaiYuTipDisposal(name)
-
-
-def create_maintenance_position(name: str = "maintenance_position") -> LaiYuMaintenancePosition:
-    """
-    创建维护位置
-    
-    Args:
-        name: 位置名称
-        
-    Returns:
-        LaiYuMaintenancePosition: 维护位置实例
-    """
-    return LaiYuMaintenancePosition(name)
-
-
-def create_standard_deck() -> LaiYuLiquidDeck:
-    """
-    创建标准工作台配置
-    
-    Returns:
-        LaiYuLiquidDeck: 配置好的工作台实例
-    """
-    # 从配置文件创建工作台
-    deck = LaiYuLiquidDeck(config=DECK_CONFIG)
-    
-    return deck
-
-
-def get_resource_by_name(deck: LaiYuLiquidDeck, name: str) -> Optional[Resource]:
-    """
-    根据名称获取资源
-    
-    Args:
-        deck: 工作台实例
-        name: 资源名称
-        
-    Returns:
-        Optional[Resource]: 找到的资源，如果不存在则返回None
-    """
-    for child in deck.children:
-        if child.name == name:
-            return child
-    return None
-
-
-def get_resources_by_type(deck: LaiYuLiquidDeck, resource_type: type) -> List[Resource]:
-    """
-    根据类型获取资源列表
-    
-    Args:
-        deck: 工作台实例
-        resource_type: 资源类型
-        
-    Returns:
-        List[Resource]: 匹配类型的资源列表
-    """
-    return [child for child in deck.children if isinstance(child, resource_type)]
-
-
-def list_all_resources(deck: LaiYuLiquidDeck) -> Dict[str, List[str]]:
-    """
-    列出所有资源
-    
-    Args:
-        deck: 工作台实例
-        
-    Returns:
-        Dict[str, List[str]]: 按类型分组的资源名称字典
-    """
-    resources = {
-        "tip_racks": [],
-        "plates": [],
-        "containers": [],
-        "positions": []
-    }
-    
-    for child in deck.children:
-        if isinstance(child, (LaiYuTipRack1000, LaiYuTipRack200)):
-            resources["tip_racks"].append(child.name)
-        elif isinstance(child, (LaiYu96WellPlate, LaiYuDeepWellPlate)):
-            resources["plates"].append(child.name)
-        elif isinstance(child, (LaiYuWasteContainer, LaiYuWashContainer, LaiYuReagentContainer)):
-            resources["containers"].append(child.name)
-        elif isinstance(child, (LaiYuTipDisposal, LaiYuMaintenancePosition)):
-            resources["positions"].append(child.name)
-    
-    return resources
-
-
-# 导出的类别名（向后兼容）
-TipRack1000ul = LaiYuTipRack1000
-TipRack200ul = LaiYuTipRack200
-Plate96Well = LaiYu96WellPlate
-Plate96DeepWell = LaiYuDeepWellPlate
-TubeRack8 = LaiYu8TubeRack
-WasteContainer = LaiYuWasteContainer
-WashContainer = LaiYuWashContainer
-ReagentContainer = LaiYuReagentContainer
-TipDisposal = LaiYuTipDisposal
-MaintenancePosition = LaiYuMaintenancePosition
--- a/unilabos/devices/laiyu_liquid/docs/CHANGELOG.md
+++ b/unilabos/devices/laiyu_liquid/docs/CHANGELOG.md
@@ -1,69 +0,0 @@
-# 更新日志
-
-本文档记录了 LaiYu_Liquid 模块的所有重要变更。
-
-## [1.0.0] - 2024-01-XX
-
-### 新增功能
- ✅ 完整的液体处理工作站集成
- ✅ RS485 通信协议支持
- ✅ SOPA 气动式移液器驱动
- ✅ XYZ 三轴步进电机控制
- ✅ PyLabRobot 兼容后端
- ✅ 标准化资源管理系统
- ✅ 96孔板、离心管架、枪头架支持
- ✅ RViz 可视化后端
- ✅ 完整的配置管理系统
- ✅ 抽象协议实现
- ✅ 生产级错误处理和日志记录
-
-### 技术特性
- **硬件支持**: SOPA移液器 + XYZ三轴运动平台
- **通信协议**: RS485总线，波特率115200
- **坐标系统**: 机械坐标与工作坐标自动转换
- **安全机制**: 限位保护、紧急停止、错误恢复
- **兼容性**: 完全兼容 PyLabRobot 框架
-
-### 文件结构
-```
-LaiYu_Liquid/
-├── core/
-│   └── LaiYu_Liquid.py      # 主模块文件
-├── __init__.py              # 模块初始化
-├── abstract_protocol.py    # 抽象协议
-├── laiyu_liquid_res.py     # 资源管理
-├── rviz_backend.py         # RViz后端
-├── backend/                # 后端驱动
-├── config/                 # 配置文件
-├── controllers/           # 控制器
-├── docs/                  # 技术文档
-└── drivers/               # 底层驱动
-```
-
-### 已知问题
- 无
-
-### 依赖要求
- Python 3.8+
- PyLabRobot
- pyserial
- asyncio
-
---
-
-## 版本说明
-
-### 版本号格式
-采用语义化版本控制 (Semantic Versioning): `MAJOR.MINOR.PATCH`
-
- **MAJOR**: 不兼容的API变更
- **MINOR**: 向后兼容的功能新增
- **PATCH**: 向后兼容的问题修复
-
-### 变更类型
- **新增功能**: 新的功能特性
- **变更**: 现有功能的变更
- **弃用**: 即将移除的功能
- **移除**: 已移除的功能
- **修复**: 问题修复
- **安全**: 安全相关的修复
--- a/unilabos/devices/laiyu_liquid/docs/hardware/SOPA气动式移液器RS485控制指令.md
+++ b/unilabos/devices/laiyu_liquid/docs/hardware/SOPA气动式移液器RS485控制指令.md
@@ -1,267 +0,0 @@
-# SOPA气动式移液器RS485控制指令合集
-
-## 1. RS485通信基本配置
-
-### 1.1 支持的设备型号
- **仅SC-STxxx-00-13支持RS485通信**
- 其他型号主要使用CAN通信
-
-### 1.2 通信参数
- **波特率**: 9600, 115200（默认值）
- **地址范围**: 1~254个设备，255为广播地址
- **通信接口**: RS485差分信号
-
-### 1.3 引脚分配（10位LIF连接器）
- **引脚7**: RS485+ (RS485通信正极)
- **引脚8**: RS485- (RS485通信负极)
-
-## 2. RS485通信协议格式
-
-### 2.1 发送数据格式
-```
-头码 | 地址 | 命令/数据 | 尾码 | 校验和
-```
-
-### 2.2 从机回应格式
-```
-头码 | 地址 | 数据（固定9字节） | 尾码 | 校验和
-```
-
-### 2.3 格式详细说明
- **头码**: 
-  - 终端调试: '/' (0x2F)
-  - OEM通信: '[' (0x5B) 
- **地址**: 设备节点地址，1~254，多字节ASCII（注意：地址不可为47，69，91）
- **命令/数据**: ASCII格式的命令字符串
- **尾码**: 'E' (0x45)
- **校验和**: 以上数据的累加值，1字节
-
-## 3. 初始化和基本控制指令
-
-### 3.1 初始化指令
-```bash
-# 初始化活塞驱动机构
-HE
-
-# 示例（OEM通信）：
-# 主机发送: 5B 32 48 45 1A
-# 从机回应开始: 2F 02 06 0A 30 00 00 00 00 00 00 45 B6
-# 从机回应完成: 2F 02 06 00 30 00 00 00 00 00 00 45 AC
-```
-
-### 3.2 枪头操作指令
-```bash
-# 顶出枪头
-RE
-
-# 枪头检测状态报告
-Q28  # 返回枪头存在状态（0=不存在，1=存在）
-```
-
-## 4. 移液控制指令
-
-### 4.1 位置控制指令
-```bash
-# 绝对位置移动（微升）
-A[n]E
-# 示例：移动到位置0
-A0E
-
-# 相对抽吸（向上移动）
-P[n]E
-# 示例：抽吸200微升
-P200E
-
-# 相对分配（向下移动）  
-D[n]E
-# 示例：分配200微升
-D200E
-```
-
-### 4.2 速度设置指令
-```bash
-# 设置最高速度（0.1ul/秒为单位）
-s[n]E
-# 示例：设置最高速度为2000（200ul/秒）
-s2000E
-
-# 设置启动速度
-b[n]E
-# 示例：设置启动速度为100（10ul/秒）
-b100E
-
-# 设置断流速度
-c[n]E
-# 示例：设置断流速度为100（10ul/秒）
-c100E
-
-# 设置加速度
-a[n]E
-# 示例：设置加速度为30000
-a30000E
-```
-
-## 5. 液体检测和安全控制指令
-
-### 5.1 吸排液检测控制
-```bash
-# 开启吸排液检测
-f1E  # 开启
-f0E  # 关闭
-
-# 设置空吸门限
-$[n]E
-# 示例：设置空吸门限为4
-$4E
-
-# 设置泡沫门限
-![n]E
-# 示例：设置泡沫门限为20
-!20E
-
-# 设置堵塞门限
-%[n]E
-# 示例：设置堵塞门限为350
-%350E
-```
-
-### 5.2 液位检测指令
-```bash
-# 压力式液位检测
-m0E  # 设置为压力探测模式
-L[n]E  # 执行液位检测，[n]为灵敏度(3~40)
-k[n]E  # 设置检测速度(100~2000)
-
-# 电容式液位检测  
-m1E  # 设置为电容探测模式
-```
-
-## 6. 状态查询和报告指令
-
-### 6.1 基本状态查询
-```bash
-# 查询固件版本
-V
-
-# 查询设备状态
-Q[n]
-# 常用查询参数：
-Q01  # 报告加速度
-Q02  # 报告启动速度  
-Q03  # 报告断流速度
-Q06  # 报告最大速度
-Q08  # 报告节点地址
-Q11  # 报告波特率
-Q18  # 报告当前位置
-Q28  # 报告枪头存在状态
-Q29  # 报告校准系数
-Q30  # 报告空吸门限
-Q31  # 报告堵针门限
-Q32  # 报告泡沫门限
-```
-
-## 7. 配置和校准指令
-
-### 7.1 校准参数设置
-```bash
-# 设置校准系数
-j[n]E
-# 示例：设置校准系数为1.04
-j1.04E
-
-# 设置补偿偏差
-e[n]E  
-# 示例：设置补偿偏差为2.03
-e2.03E
-
-# 设置吸头容量
-C[n]E
-# 示例：设置1000ul吸头
-C1000E
-```
-
-### 7.2 高级控制参数
-```bash
-# 设置回吸粘度
-][n]E
-# 示例：设置回吸粘度为30
-]30E
-
-# 延时控制
-M[n]E
-# 示例：延时1000毫秒
-M1000E
-```
-
-## 8. 复合操作指令示例
-
-### 8.1 标准移液操作
-```bash
-# 完整的200ul移液操作
-a30000b200c200s2000P200E
-# 解析：设置加速度30000 + 启动速度200 + 断流速度200 + 最高速度2000 + 抽吸200ul + 执行
-```
-
-### 8.2 带检测的移液操作
-```bash
-# 带空吸检测的200ul抽吸
-a30000b200c200s2000f1P200f0E
-# 解析：设置参数 + 开启检测 + 抽吸200ul + 关闭检测 + 执行
-```
-
-### 8.3 液面检测操作
-```bash
-# 压力式液面检测
-m0k200L5E
-# 解析：压力模式 + 检测速度200 + 灵敏度5 + 执行检测
-
-# 电容式液面检测  
-m1L3E
-# 解析：电容模式 + 灵敏度3 + 执行检测
-```
-
-## 9. 错误处理
-
-### 9.1 状态字节说明
- **00h**: 无错误
- **01h**: 上次动作未完成
- **02h**: 设备未初始化  
- **03h**: 设备过载
- **04h**: 无效指令
- **05h**: 液位探测故障
- **0Dh**: 空吸
- **0Eh**: 堵针
- **10h**: 泡沫
- **11h**: 吸液超过吸头容量
-
-### 9.2 错误查询
-```bash
-# 查询当前错误状态
-Q  # 返回状态字节和错误代码
-```
-
-## 10. 通信示例
-
-### 10.1 基本通信流程
-1. **执行命令**: 主机发送命令 → 从机确认 → 从机执行 → 从机回应完成
-2. **读取数据**: 主机发送查询 → 从机确认 → 从机返回数据
-
-### 10.2 快速指令表
-| 操作 | 指令 | 说明 |
-|------|------|------|
-| 初始化 | `HE` | 初始化设备 |
-| 退枪头 | `RE` | 顶出枪头 |
-| 吸液200ul | `a30000b200c200s2000P200E` | 基本吸液 |
-| 带检测吸液 | `a30000b200c200s2000f1P200f0E` | 开启空吸检测 |
-| 吐液200ul | `a300000b500c500s6000D200E` | 基本分配 |
-| 压力液面检测 | `m0k200L5E` | pLLD检测 |
-| 电容液面检测 | `m1L3E` | cLLD检测 |
-
-## 11. 注意事项
-
-1. **地址限制**: RS485地址不可设为47、69、91
-2. **校验和**: 终端调试时不关心校验和，OEM通信需要校验
-3. **ASCII格式**: 所有命令和参数都使用ASCII字符
-4. **执行指令**: 大部分命令需要以'E'结尾才能执行
-5. **设备支持**: 只有SC-STxxx-00-13型号支持RS485通信
-6. **波特率设置**: 默认115200，可设置为9600
--- a/unilabos/devices/laiyu_liquid/docs/hardware/步进电机控制指令.md
+++ b/unilabos/devices/laiyu_liquid/docs/hardware/步进电机控制指令.md
@@ -1,162 +0,0 @@
-# 步进电机B系列控制指令详解
-
-## 基本通信参数
- **通信方式**: RS485
- **协议**: Modbus
- **波特率**: 115200 (默认)
- **数据位**: 8位
- **停止位**: 1位
- **校验位**: 无
- **默认站号**: 1 (可设置1-254)
-
-## 支持的功能码
- **03H**: 读取寄存器
- **06H**: 写入单个寄存器  
- **10H**: 写入多个寄存器
-
-## 寄存器地址表
-
-### 状态监控寄存器 (只读)
-| 地址 | 功能码 | 内容 | 说明 |
-|------|--------|------|------|
-| 00H | 03H | 电机状态 | 0000H-待机/到位, 0001H-运行中, 0002H-碰撞停, 0003H-正光电停, 0004H-反光电停 |
-| 01H | 03H | 实际步数高位 | 当前电机位置的高16位 |
-| 02H | 03H | 实际步数低位 | 当前电机位置的低16位 |
-| 03H | 03H | 实际速度 | 当前转速 (rpm) |
-| 05H | 03H | 电流 | 当前工作电流 (mA) |
-
-### 控制寄存器 (读写)
-| 地址 | 功能码 | 内容 | 说明 |
-|------|--------|------|------|
-| 04H | 03H/06H/10H | 急停指令 | 紧急停止控制 |
-| 06H | 03H/06H/10H | 失能控制 | 1-使能, 0-失能 |
-| 07H | 03H/06H/10H | PWM输出 | 0-1000对应0%-100%占空比 |
-| 0EH | 03H/06H/10H | 单圈绝对值归零 | 归零指令 |
-| 0FH | 03H/06H/10H | 归零指令 | 定点模式归零速度设置 |
-
-### 位置模式寄存器
-| 地址 | 功能码 | 内容 | 说明 |
-|------|--------|------|------|
-| 10H | 03H/06H/10H | 目标步数高位 | 目标位置高16位 |
-| 11H | 03H/06H/10H | 目标步数低位 | 目标位置低16位 |
-| 12H | 03H/06H/10H | 保留 | - |
-| 13H | 03H/06H/10H | 速度 | 运行速度 (rpm) |
-| 14H | 03H/06H/10H | 加速度 | 0-60000 rpm/s |
-| 15H | 03H/06H/10H | 精度 | 到位精度设置 |
-
-### 速度模式寄存器
-| 地址 | 功能码 | 内容 | 说明 |
-|------|--------|------|------|
-| 60H | 03H/06H/10H | 保留 | - |
-| 61H | 03H/06H/10H | 速度 | 正值正转，负值反转 |
-| 62H | 03H/06H/10H | 加速度 | 0-60000 rpm/s |
-
-### 设备参数寄存器
-| 地址 | 功能码 | 内容 | 默认值 | 说明 |
-|------|--------|------|--------|------|
-| E0H | 03H/06H/10H | 设备地址 | 0001H | Modbus从站地址 |
-| E1H | 03H/06H/10H | 堵转电流 | 0BB8H | 堵转检测电流阈值 |
-| E2H | 03H/06H/10H | 保留 | 0258H | - |
-| E3H | 03H/06H/10H | 每圈步数 | 0640H | 细分设置 |
-| E4H | 03H/06H/10H | 限位开关使能 | F000H | 1-使能, 0-禁用 |
-| E5H | 03H/06H/10H | 堵转逻辑 | 0000H | 00-断电, 01-对抗 |
-| E6H | 03H/06H/10H | 堵转时间 | 0000H | 堵转检测时间(ms) |
-| E7H | 03H/06H/10H | 默认速度 | 1388H | 上电默认速度 |
-| E8H | 03H/06H/10H | 默认加速度 | EA60H | 上电默认加速度 |
-| E9H | 03H/06H/10H | 默认精度 | 0064H | 上电默认精度 |
-| EAH | 03H/06H/10H | 波特率高位 | 0001H | 通信波特率设置 |
-| EBH | 03H/06H/10H | 波特率低位 | C200H | 115200对应01C200H |
-
-### 版本信息寄存器 (只读)
-| 地址 | 功能码 | 内容 | 说明 |
-|------|--------|------|------|
-| F0H | 03H | 版本号 | 固件版本信息 |
-| F1H-F4H | 03H | 型号 | 产品型号信息 |
-
-## 常用控制指令示例
-
-### 读取电机状态
-```
-发送: 01 03 00 00 00 01 84 0A
-接收: 01 03 02 00 01 79 84
-说明: 电机状态为0001H (正在运行)
-```
-
-### 读取当前位置
-```
-发送: 01 03 00 01 00 02 95 CB  
-接收: 01 03 04 00 19 00 00 2B F4
-说明: 当前位置为1638400步 (100圈)
-```
-
-### 停止电机
-```
-发送: 01 10 00 04 00 01 02 00 00 A7 D4
-接收: 01 10 00 04 00 01 40 08
-说明: 急停指令
-```
-
-### 位置模式运动
-```
-发送: 01 10 00 10 00 06 0C 00 19 00 00 00 00 13 88 00 00 00 00 9F FB
-接收: 01 10 00 10 00 06 41 CE
-说明: 以5000rpm速度运动到1638400步位置
-```
-
-### 速度模式 - 正转
-```
-发送: 01 10 00 60 00 04 08 00 00 13 88 00 FA 00 00 F4 77
-接收: 01 10 00 60 00 04 C1 D4
-说明: 以5000rpm速度正转
-```
-
-### 速度模式 - 反转
-```
-发送: 01 10 00 60 00 04 08 00 00 EC 78 00 FA 00 00 A0 6D
-接收: 01 10 00 60 00 04 C1 D4
-说明: 以5000rpm速度反转 (EC78H = -5000)
-```
-
-### 设置设备地址
-```
-发送: 00 06 00 E0 00 02 C9 F1
-接收: 00 06 00 E0 00 02 C9 F1
-说明: 将设备地址设置为2
-```
-
-## 错误码
-| 状态码 | 含义 |
-|--------|------|
-| 0001H | 功能码错误 |
-| 0002H | 地址错误 |
-| 0003H | 长度错误 |
-
-## CRC校验算法
-```c
-public static byte[] ModBusCRC(byte[] data, int offset, int cnt) {
-    int wCrc = 0x0000FFFF;
-    byte[] CRC = new byte[2];
-    for (int i = 0; i < cnt; i++) {
-        wCrc ^= ((data[i + offset]) & 0xFF);
-        for (int j = 0; j < 8; j++) {
-            if ((wCrc & 0x00000001) == 1) {
-                wCrc >>= 1;
-                wCrc ^= 0x0000A001;
-            } else {
-                wCrc >>= 1;
-            }
-        }
-    }
-    CRC[1] = (byte) ((wCrc & 0x0000FF00) >> 8);
-    CRC[0] = (byte) (wCrc & 0x000000FF);
-    return CRC;
-}
-```
-
-## 注意事项
-1. 所有16位数据采用大端序传输
-2. 步数计算: 实际步数 = 高位<<16 | 低位
-3. 负数使用补码表示
-4. PWM输出K脚: 0%开漏, 100%接地, 其他输出1KHz PWM
-5. 光电开关需使用NPN开漏型
-6. 限位开关: LF正向, LB反向
--- a/unilabos/devices/laiyu_liquid/docs/hardware/硬件连接配置指南.md
+++ b/unilabos/devices/laiyu_liquid/docs/hardware/硬件连接配置指南.md
--- a/unilabos/devices/laiyu_liquid/docs/readme.md
+++ b/unilabos/devices/laiyu_liquid/docs/readme.md
@@ -1,269 +0,0 @@
-# LaiYu_Liquid 液体处理工作站
-
-## 概述
-
-LaiYu_Liquid 是一个完全集成到 UniLabOS 的自动化液体处理工作站，基于 RS485 通信协议，专为精确的液体分配和转移操作而设计。本模块已完成生产环境部署准备，提供完整的硬件控制、资源管理和标准化接口。
-
-## 系统组成
-
-### 硬件组件
- **XYZ三轴运动平台**: 3个RS485步进电机驱动（地址：X轴=0x01, Y轴=0x02, Z轴=0x03）
- **SOPA气动式移液器**: RS485总线控制，支持精密液体处理操作
- **通信接口**: RS485转USB模块，默认波特率115200
- **机械结构**: 稳固工作台面，支持离心管架、96孔板等标准实验耗材
-
-### 软件架构
- **驱动层**: 底层硬件通信驱动，支持RS485协议
- **控制层**: 高级控制逻辑和坐标系管理
- **抽象层**: 完全符合UniLabOS标准的液体处理接口
- **资源层**: 标准化的实验器具和耗材管理
-
-## 🎯 生产就绪组件
-
-### ✅ 核心驱动程序 (`drivers/`)
- **`sopa_pipette_driver.py`** - SOPA移液器完整驱动
-  - 支持液体吸取、分配、检测
-  - 完整的错误处理和状态管理
-  - 生产级别的通信协议实现
-  
- **`xyz_stepper_driver.py`** - XYZ三轴步进电机驱动
-  - 精确的位置控制和运动规划
-  - 安全限位和错误检测
-  - 高性能运动控制算法
-
-### ✅ 高级控制器 (`controllers/`)
- **`pipette_controller.py`** - 移液控制器
-  - 封装高级液体处理功能
-  - 支持多种液体类型和处理参数
-  - 智能错误恢复机制
-  
- **`xyz_controller.py`** - XYZ运动控制器
-  - 坐标系管理和转换
-  - 运动路径优化
-  - 安全运动控制
-
-### ✅ UniLabOS集成 (`core/LaiYu_Liquid.py`)
- **完整的液体处理抽象接口**
- **标准化的资源管理系统**
- **与PyLabRobot兼容的后端实现**
- **生产级别的错误处理和日志记录**
-
-### ✅ 资源管理系统
- **`laiyu_liquid_res.py`** - 标准化资源定义
-  - 96孔板、离心管架、枪头架等标准器具
-  - 自动化的资源创建和配置函数
-  - 与工作台布局的完美集成
-
-### ✅ 配置管理 (`config/`)
- **`config/deck.json`** - 工作台布局配置
-  - 精确的空间定义和槽位管理
-  - 支持多种实验器具的标准化放置
-  - 可扩展的配置架构
-
- **`__init__.py`** - 模块集成和导出
-  - 完整的API导出和版本管理
-  - 依赖检查和安装验证
-  - 专业的模块信息展示
-
-<!-- ### ✅ 可视化支持
- **`rviz_backend.py`** - RViz可视化后端
-  - 实时运动状态可视化
-  - 液体处理过程监控
-  - 与ROS系统的无缝集成 -->
-
-## 🚀 核心功能特性
-
-### 液体处理能力
- **精密体积控制**: 支持1-1000μL精确分配
- **多种液体类型**: 水性、有机溶剂、粘稠液体等
- **智能检测**: 液位检测、气泡检测、堵塞检测
- **自动化流程**: 完整的吸取-转移-分配工作流
-
-### 运动控制系统
- **三轴精密定位**: 微米级精度控制
- **路径优化**: 智能运动规划和碰撞避免
- **安全机制**: 限位保护、紧急停止、错误恢复
- **坐标系管理**: 工作坐标与机械坐标的自动转换
-
-### 资源管理
- **标准化器具**: 支持96孔板、离心管架、枪头架等
- **状态跟踪**: 实时监控液体体积、枪头状态等
- **自动配置**: 基于JSON的灵活配置系统
- **扩展性**: 易于添加新的器具类型
-
-## 📁 目录结构
-
-```
-LaiYu_Liquid/
-├── __init__.py              # 模块初始化和API导出
-├── readme.md               # 本文档
-├── backend/                # 后端驱动模块
-│   ├── __init__.py
-│   └── laiyu_backend.py    # PyLabRobot兼容后端
-├── core/                   # 核心模块
-│   ├── core/
-│   │   └── LaiYu_Liquid.py    # 主设备类
-│   ├── abstract_protocol.py # 抽象协议
-│   └── laiyu_liquid_res.py # 设备资源定义
-├── config/                 # 配置文件目录
-│   └── deck.json          # 工作台布局配置
-├── controllers/           # 高级控制器
-│   ├── __init__.py
-│   ├── pipette_controller.py  # 移液控制器
-│   └── xyz_controller.py      # XYZ运动控制器
-├── docs/                  # 技术文档
-│   ├── SOPA气动式移液器RS485控制指令.md
-│   ├── 步进电机控制指令.md
-│   └── hardware/          # 硬件相关文档
-├── drivers/               # 底层驱动程序
-│   ├── __init__.py
-│   ├── sopa_pipette_driver.py  # SOPA移液器驱动
-│   └── xyz_stepper_driver.py   # XYZ步进电机驱动
-└── tests/                 # 测试文件
-```
-
-## 🔧 快速开始
-
-### 1. 安装和验证
-
-```python
-# 验证模块安装
-from unilabos.devices.laiyu_liquid import (
-    LaiYuLiquid,
-    LaiYuLiquidConfig,
-    create_quick_setup,
-    print_module_info
-)
-
-# 查看模块信息
-print_module_info()
-
-# 快速创建默认资源
-resources = create_quick_setup()
-print(f"已创建 {len(resources)} 个资源")
-```
-
-### 2. 基本使用示例
-
-```python
-from unilabos.devices.LaiYu_Liquid import (
-    create_quick_setup, 
-    create_96_well_plate,
-    create_laiyu_backend
-)
-
-# 快速创建默认资源
-resources = create_quick_setup()
-print(f"创建了以下资源: {list(resources.keys())}")
-
-# 创建96孔板
-plate_96 = create_96_well_plate("test_plate")
-print(f"96孔板包含 {len(plate_96.children)} 个孔位")
-
-# 创建后端实例（用于PyLabRobot集成）
-backend = create_laiyu_backend("LaiYu_Device")
-print(f"后端设备: {backend.name}")
-```
-
-### 3. 后端驱动使用
-
-```python
-from unilabos.devices.laiyu_liquid.backend import create_laiyu_backend
-
-# 创建后端实例
-backend = create_laiyu_backend("LaiYu_Liquid_Station")
-
-# 连接设备
-await backend.connect()
-
-# 设备归位
-await backend.home_device()
-
-# 获取设备状态
-status = await backend.get_status()
-print(f"设备状态: {status}")
-
-# 断开连接
-await backend.disconnect()
-```
-
-### 4. 资源管理示例
-
-```python
-from unilabos.devices.LaiYu_Liquid import (
-    create_centrifuge_tube_rack,
-    create_tip_rack,
-    load_deck_config
-)
-
-# 加载工作台配置
-deck_config = load_deck_config()
-print(f"工作台尺寸: {deck_config['size_x']}x{deck_config['size_y']}mm")
-
-# 创建不同类型的资源
-tube_rack = create_centrifuge_tube_rack("sample_rack")
-tip_rack = create_tip_rack("tip_rack_200ul")
-
-print(f"离心管架: {tube_rack.name}, 容量: {len(tube_rack.children)} 个位置")
-print(f"枪头架: {tip_rack.name}, 容量: {len(tip_rack.children)} 个枪头")
-```
-
-## 🔍 技术架构
-
-### 坐标系统
- **机械坐标**: 基于步进电机的原始坐标系统
- **工作坐标**: 用户友好的实验室坐标系统
- **自动转换**: 透明的坐标系转换和校准
-
-### 通信协议
- **RS485总线**: 高可靠性工业通信标准
- **Modbus协议**: 标准化的设备通信协议
- **错误检测**: 完整的通信错误检测和恢复
-
-### 安全机制
- **限位保护**: 硬件和软件双重限位保护
- **紧急停止**: 即时停止所有运动和操作
- **状态监控**: 实时设备状态监控和报警
-
-## 🧪 验证和测试
-
-### 功能验证
-```python
-# 验证模块安装
-from unilabos.devices.laiyu_liquid import validate_installation
-validate_installation()
-
-# 查看模块信息
-from unilabos.devices.laiyu_liquid import print_module_info
-print_module_info()
-```
-
-### 硬件连接测试
-```python
-# 测试SOPA移液器连接
-from unilabos.devices.laiyu_liquid.drivers import SOPAPipette, SOPAConfig
-
-config = SOPAConfig(port="/dev/cu.usbserial-3130", address=4)
-pipette = SOPAPipette(config)
-success = pipette.connect()
-print(f"SOPA连接状态: {'成功' if success else '失败'}")
-```
-
-## 📚 维护和支持
-
-### 日志记录
- **结构化日志**: 使用Python logging模块的专业日志记录
- **错误追踪**: 详细的错误信息和堆栈跟踪
- **性能监控**: 操作时间和性能指标记录
-
-### 配置管理
- **JSON配置**: 灵活的JSON格式配置文件
- **参数验证**: 自动配置参数验证和错误提示
- **热重载**: 支持配置文件的动态重载
-
-### 扩展性
- **模块化设计**: 易于扩展和定制的模块化架构
- **插件接口**: 支持第三方插件和扩展
- **API兼容**: 向后兼容的API设计
-
-
--- a/unilabos/devices/laiyu_liquid/drivers/init.py
+++ b/unilabos/devices/laiyu_liquid/drivers/init.py
@@ -1,30 +0,0 @@
-"""
-LaiYu_Liquid 驱动程序模块
-
-该模块包含了LaiYu_Liquid液体处理工作站的硬件驱动程序：
- SOPA移液器驱动程序
- XYZ步进电机驱动程序
-"""
-
-# SOPA移液器驱动程序导入
-from .sopa_pipette_driver import SOPAPipette, SOPAConfig, SOPAStatusCode
-
-# XYZ步进电机驱动程序导入  
-from .xyz_stepper_driver import StepperMotorDriver, XYZStepperController, MotorAxis, MotorStatus
-
-__all__ = [
-    # SOPA移液器
-    "SOPAPipette",
-    "SOPAConfig",
-    "SOPAStatusCode",
-    
-    # XYZ步进电机
-    "StepperMotorDriver", 
-    "XYZStepperController",
-    "MotorAxis",
-    "MotorStatus",
-]
-
-__version__ = "1.0.0"
-__author__ = "LaiYu_Liquid Driver Team"
-__description__ = "LaiYu_Liquid 硬件驱动程序集合"
--- a/unilabos/devices/laiyu_liquid/drivers/sopa_pipette_driver.py
+++ b/unilabos/devices/laiyu_liquid/drivers/sopa_pipette_driver.py
--- a/unilabos/devices/laiyu_liquid/drivers/xyz_stepper_driver.py
+++ b/unilabos/devices/laiyu_liquid/drivers/xyz_stepper_driver.py
@@ -1,663 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-XYZ三轴步进电机B系列驱动程序
-支持RS485通信，Modbus协议
-"""
-
-import serial
-import struct
-import time
-import logging
-from typing import Optional, Tuple, Dict, Any
-from enum import Enum
-from dataclasses import dataclass
-
-# 配置日志
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class MotorAxis(Enum):
-    """电机轴枚举"""
-    X = 1
-    Y = 2
-    Z = 3
-
-
-class MotorStatus(Enum):
-    """电机状态枚举"""
-    STANDBY = 0x0000  # 待机/到位
-    RUNNING = 0x0001  # 运行中
-    COLLISION_STOP = 0x0002  # 碰撞停
-    FORWARD_LIMIT_STOP = 0x0003  # 正光电停
-    REVERSE_LIMIT_STOP = 0x0004  # 反光电停
-
-
-class ModbusFunction(Enum):
-    """Modbus功能码"""
-    READ_HOLDING_REGISTERS = 0x03
-    WRITE_SINGLE_REGISTER = 0x06
-    WRITE_MULTIPLE_REGISTERS = 0x10
-
-
-@dataclass
-class MotorPosition:
-    """电机位置信息"""
-    steps: int
-    speed: int
-    current: int
-    status: MotorStatus
-
-
-class ModbusException(Exception):
-    """Modbus通信异常"""
-    pass
-
-
-class StepperMotorDriver:
-    """步进电机驱动器基类"""
-    
-    # 寄存器地址常量
-    REG_STATUS = 0x00
-    REG_POSITION_HIGH = 0x01
-    REG_POSITION_LOW = 0x02
-    REG_ACTUAL_SPEED = 0x03
-    REG_EMERGENCY_STOP = 0x04
-    REG_CURRENT = 0x05
-    REG_ENABLE = 0x06
-    REG_PWM_OUTPUT = 0x07
-    REG_ZERO_SINGLE = 0x0E
-    REG_ZERO_COMMAND = 0x0F
-    
-    # 位置模式寄存器
-    REG_TARGET_POSITION_HIGH = 0x10
-    REG_TARGET_POSITION_LOW = 0x11
-    REG_POSITION_SPEED = 0x13
-    REG_POSITION_ACCELERATION = 0x14
-    REG_POSITION_PRECISION = 0x15
-    
-    # 速度模式寄存器
-    REG_SPEED_MODE_SPEED = 0x61
-    REG_SPEED_MODE_ACCELERATION = 0x62
-    
-    # 设备参数寄存器
-    REG_DEVICE_ADDRESS = 0xE0
-    REG_DEFAULT_SPEED = 0xE7
-    REG_DEFAULT_ACCELERATION = 0xE8
-    
-    def __init__(self, port: str, baudrate: int = 115200, timeout: float = 1.0):
-        """
-        初始化步进电机驱动器
-        
-        Args:
-            port: 串口端口名
-            baudrate: 波特率
-            timeout: 通信超时时间
-        """
-        self.port = port
-        self.baudrate = baudrate
-        self.timeout = timeout
-        self.serial_conn: Optional[serial.Serial] = None
-        
-    def connect(self) -> bool:
-        """
-        建立串口连接
-        
-        Returns:
-            连接是否成功
-        """
-        try:
-            self.serial_conn = serial.Serial(
-                port=self.port,
-                baudrate=self.baudrate,
-                bytesize=serial.EIGHTBITS,
-                parity=serial.PARITY_NONE,
-                stopbits=serial.STOPBITS_ONE,
-                timeout=self.timeout
-            )
-            logger.info(f"已连接到串口: {self.port}")
-            return True
-        except Exception as e:
-            logger.error(f"串口连接失败: {e}")
-            return False
-    
-    def disconnect(self) -> None:
-        """关闭串口连接"""
-        if self.serial_conn and self.serial_conn.is_open:
-            self.serial_conn.close()
-            logger.info("串口连接已关闭")
-    
-    def __enter__(self):
-        """上下文管理器入口"""
-        if self.connect():
-            return self
-        raise ModbusException("无法建立串口连接")
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """上下文管理器出口"""
-        self.disconnect()
-    
-    @staticmethod
-    def calculate_crc(data: bytes) -> bytes:
-        """
-        计算Modbus CRC校验码
-        
-        Args:
-            data: 待校验的数据
-            
-        Returns:
-            CRC校验码 (2字节)
-        """
-        crc = 0xFFFF
-        for byte in data:
-            crc ^= byte
-            for _ in range(8):
-                if crc & 0x0001:
-                    crc >>= 1
-                    crc ^= 0xA001
-                else:
-                    crc >>= 1
-        return struct.pack('<H', crc)
-    
-    def _send_command(self, slave_addr: int, data: bytes) -> bytes:
-        """
-        发送Modbus命令并接收响应
-        
-        Args:
-            slave_addr: 从站地址
-            data: 命令数据
-            
-        Returns:
-            响应数据
-            
-        Raises:
-            ModbusException: 通信异常
-        """
-        if not self.serial_conn or not self.serial_conn.is_open:
-            raise ModbusException("串口未连接")
-        
-        # 构建完整命令
-        command = bytes([slave_addr]) + data
-        crc = self.calculate_crc(command)
-        full_command = command + crc
-        
-        # 清空接收缓冲区
-        self.serial_conn.reset_input_buffer()
-        
-        # 发送命令
-        self.serial_conn.write(full_command)
-        logger.debug(f"发送命令: {' '.join(f'{b:02X}' for b in full_command)}")
-        
-        # 等待响应
-        time.sleep(0.01)  # 短暂延时
-        
-        # 读取响应
-        response = self.serial_conn.read(256)  # 最大读取256字节
-        if not response:
-            raise ModbusException("未收到响应")
-        
-        logger.debug(f"接收响应: {' '.join(f'{b:02X}' for b in response)}")
-        
-        # 验证CRC
-        if len(response) < 3:
-            raise ModbusException("响应数据长度不足")
-        
-        data_part = response[:-2]
-        received_crc = response[-2:]
-        calculated_crc = self.calculate_crc(data_part)
-        
-        if received_crc != calculated_crc:
-            raise ModbusException("CRC校验失败")
-        
-        return response
-    
-    def read_registers(self, slave_addr: int, start_addr: int, count: int) -> list:
-        """
-        读取保持寄存器
-        
-        Args:
-            slave_addr: 从站地址
-            start_addr: 起始地址
-            count: 寄存器数量
-            
-        Returns:
-            寄存器值列表
-        """
-        data = struct.pack('>BHH', ModbusFunction.READ_HOLDING_REGISTERS.value, start_addr, count)
-        response = self._send_command(slave_addr, data)
-        
-        if len(response) < 5:
-            raise ModbusException("响应长度不足")
-        
-        if response[1] != ModbusFunction.READ_HOLDING_REGISTERS.value:
-            raise ModbusException(f"功能码错误: {response[1]:02X}")
-        
-        byte_count = response[2]
-        values = []
-        for i in range(0, byte_count, 2):
-            value = struct.unpack('>H', response[3+i:5+i])[0]
-            values.append(value)
-        
-        return values
-    
-    def write_single_register(self, slave_addr: int, addr: int, value: int) -> bool:
-        """
-        写入单个寄存器
-        
-        Args:
-            slave_addr: 从站地址
-            addr: 寄存器地址
-            value: 寄存器值
-            
-        Returns:
-            写入是否成功
-        """
-        data = struct.pack('>BHH', ModbusFunction.WRITE_SINGLE_REGISTER.value, addr, value)
-        response = self._send_command(slave_addr, data)
-        
-        return len(response) >= 8 and response[1] == ModbusFunction.WRITE_SINGLE_REGISTER.value
-    
-    def write_multiple_registers(self, slave_addr: int, start_addr: int, values: list) -> bool:
-        """
-        写入多个寄存器
-        
-        Args:
-            slave_addr: 从站地址
-            start_addr: 起始地址
-            values: 寄存器值列表
-            
-        Returns:
-            写入是否成功
-        """
-        byte_count = len(values) * 2
-        data = struct.pack('>BHHB', ModbusFunction.WRITE_MULTIPLE_REGISTERS.value, 
-                          start_addr, len(values), byte_count)
-        
-        for value in values:
-            data += struct.pack('>H', value)
-        
-        response = self._send_command(slave_addr, data)
-        
-        return len(response) >= 8 and response[1] == ModbusFunction.WRITE_MULTIPLE_REGISTERS.value
-
-
-class XYZStepperController(StepperMotorDriver):
-    """XYZ三轴步进电机控制器"""
-    
-    # 电机配置常量
-    STEPS_PER_REVOLUTION = 16384  # 每圈步数
-    
-    def __init__(self, port: str, baudrate: int = 115200, timeout: float = 1.0):
-        """
-        初始化XYZ三轴步进电机控制器
-        
-        Args:
-            port: 串口端口名
-            baudrate: 波特率
-            timeout: 通信超时时间
-        """
-        super().__init__(port, baudrate, timeout)
-        self.axis_addresses = {
-            MotorAxis.X: 1,
-            MotorAxis.Y: 2,
-            MotorAxis.Z: 3
-        }
-    
-    def degrees_to_steps(self, degrees: float) -> int:
-        """
-        将角度转换为步数
-        
-        Args:
-            degrees: 角度值
-            
-        Returns:
-            对应的步数
-        """
-        return int(degrees * self.STEPS_PER_REVOLUTION / 360.0)
-    
-    def steps_to_degrees(self, steps: int) -> float:
-        """
-        将步数转换为角度
-        
-        Args:
-            steps: 步数
-            
-        Returns:
-            对应的角度值
-        """
-        return steps * 360.0 / self.STEPS_PER_REVOLUTION
-    
-    def revolutions_to_steps(self, revolutions: float) -> int:
-        """
-        将圈数转换为步数
-        
-        Args:
-            revolutions: 圈数
-            
-        Returns:
-            对应的步数
-        """
-        return int(revolutions * self.STEPS_PER_REVOLUTION)
-    
-    def steps_to_revolutions(self, steps: int) -> float:
-        """
-        将步数转换为圈数
-        
-        Args:
-            steps: 步数
-            
-        Returns:
-            对应的圈数
-        """
-        return steps / self.STEPS_PER_REVOLUTION
-    
-    def get_motor_status(self, axis: MotorAxis) -> MotorPosition:
-        """
-        获取电机状态信息
-        
-        Args:
-            axis: 电机轴
-            
-        Returns:
-            电机位置信息
-        """
-        addr = self.axis_addresses[axis]
-        
-        # 读取状态、位置、速度、电流
-        values = self.read_registers(addr, self.REG_STATUS, 6)
-        
-        status = MotorStatus(values[0])
-        position_high = values[1]
-        position_low = values[2]
-        speed = values[3]
-        current = values[5]
-        
-        # 合并32位位置
-        position = (position_high << 16) | position_low
-        # 处理有符号数
-        if position > 0x7FFFFFFF:
-            position -= 0x100000000
-        
-        return MotorPosition(position, speed, current, status)
-    
-    def emergency_stop(self, axis: MotorAxis) -> bool:
-        """
-        紧急停止电机
-        
-        Args:
-            axis: 电机轴
-            
-        Returns:
-            操作是否成功
-        """
-        addr = self.axis_addresses[axis]
-        return self.write_single_register(addr, self.REG_EMERGENCY_STOP, 0x0000)
-    
-    def enable_motor(self, axis: MotorAxis, enable: bool = True) -> bool:
-        """
-        使能/失能电机
-        
-        Args:
-            axis: 电机轴
-            enable: True为使能，False为失能
-            
-        Returns:
-            操作是否成功
-        """
-        addr = self.axis_addresses[axis]
-        value = 0x0001 if enable else 0x0000
-        return self.write_single_register(addr, self.REG_ENABLE, value)
-    
-    def move_to_position(self, axis: MotorAxis, position: int, speed: int = 5000, 
-                        acceleration: int = 1000, precision: int = 100) -> bool:
-        """
-        移动到指定位置
-        
-        Args:
-            axis: 电机轴
-            position: 目标位置(步数)
-            speed: 运行速度(rpm)
-            acceleration: 加速度(rpm/s)
-            precision: 到位精度
-            
-        Returns:
-            操作是否成功
-        """
-        addr = self.axis_addresses[axis]
-        
-        # 处理32位位置
-        if position < 0:
-            position += 0x100000000
-        
-        position_high = (position >> 16) & 0xFFFF
-        position_low = position & 0xFFFF
-        
-        values = [
-            position_high,     # 目标位置高位
-            position_low,      # 目标位置低位
-            0x0000,           # 保留
-            speed,            # 速度
-            acceleration,     # 加速度
-            precision         # 精度
-        ]
-        
-        return self.write_multiple_registers(addr, self.REG_TARGET_POSITION_HIGH, values)
-    
-    def set_speed_mode(self, axis: MotorAxis, speed: int, acceleration: int = 1000) -> bool:
-        """
-        设置速度模式运行
-        
-        Args:
-            axis: 电机轴
-            speed: 运行速度(rpm)，正值正转，负值反转
-            acceleration: 加速度(rpm/s)
-            
-        Returns:
-            操作是否成功
-        """
-        addr = self.axis_addresses[axis]
-        
-        # 处理负数
-        if speed < 0:
-            speed = 0x10000 + speed  # 补码表示
-        
-        values = [0x0000, speed, acceleration, 0x0000]
-        
-        return self.write_multiple_registers(addr, 0x60, values)
-    
-    def home_axis(self, axis: MotorAxis) -> bool:
-        """
-        轴归零操作
-        
-        Args:
-            axis: 电机轴
-            
-        Returns:
-            操作是否成功
-        """
-        addr = self.axis_addresses[axis]
-        return self.write_single_register(addr, self.REG_ZERO_SINGLE, 0x0001)
-    
-    def wait_for_completion(self, axis: MotorAxis, timeout: float = 30.0) -> bool:
-        """
-        等待电机运动完成
-        
-        Args:
-            axis: 电机轴
-            timeout: 超时时间(秒)
-            
-        Returns:
-            是否在超时前完成
-        """
-        start_time = time.time()
-        
-        while time.time() - start_time < timeout:
-            status = self.get_motor_status(axis)
-            if status.status == MotorStatus.STANDBY:
-                return True
-            time.sleep(0.1)
-        
-        logger.warning(f"{axis.name}轴运动超时")
-        return False
-    
-    def move_xyz(self, x: Optional[int] = None, y: Optional[int] = None, z: Optional[int] = None,
-                speed: int = 5000, acceleration: int = 1000) -> Dict[MotorAxis, bool]:
-        """
-        同时控制XYZ轴移动
-        
-        Args:
-            x: X轴目标位置
-            y: Y轴目标位置
-            z: Z轴目标位置
-            speed: 运行速度
-            acceleration: 加速度
-            
-        Returns:
-            各轴操作结果字典
-        """
-        results = {}
-        
-        if x is not None:
-            results[MotorAxis.X] = self.move_to_position(MotorAxis.X, x, speed, acceleration)
-        
-        if y is not None:
-            results[MotorAxis.Y] = self.move_to_position(MotorAxis.Y, y, speed, acceleration)
-        
-        if z is not None:
-            results[MotorAxis.Z] = self.move_to_position(MotorAxis.Z, z, speed, acceleration)
-        
-        return results
-    
-    def move_xyz_degrees(self, x_deg: Optional[float] = None, y_deg: Optional[float] = None, 
-                        z_deg: Optional[float] = None, speed: int = 5000, 
-                        acceleration: int = 1000) -> Dict[MotorAxis, bool]:
-        """
-        使用角度值同时移动多个轴到指定位置
-        
-        Args:
-            x_deg: X轴目标角度（度）
-            y_deg: Y轴目标角度（度）
-            z_deg: Z轴目标角度（度）
-            speed: 移动速度
-            acceleration: 加速度
-            
-        Returns:
-            各轴移动操作结果
-        """
-        # 将角度转换为步数
-        x_steps = self.degrees_to_steps(x_deg) if x_deg is not None else None
-        y_steps = self.degrees_to_steps(y_deg) if y_deg is not None else None
-        z_steps = self.degrees_to_steps(z_deg) if z_deg is not None else None
-        
-        return self.move_xyz(x_steps, y_steps, z_steps, speed, acceleration)
-    
-    def move_xyz_revolutions(self, x_rev: Optional[float] = None, y_rev: Optional[float] = None, 
-                           z_rev: Optional[float] = None, speed: int = 5000, 
-                           acceleration: int = 1000) -> Dict[MotorAxis, bool]:
-        """
-        使用圈数值同时移动多个轴到指定位置
-        
-        Args:
-            x_rev: X轴目标圈数
-            y_rev: Y轴目标圈数
-            z_rev: Z轴目标圈数
-            speed: 移动速度
-            acceleration: 加速度
-            
-        Returns:
-            各轴移动操作结果
-        """
-        # 将圈数转换为步数
-        x_steps = self.revolutions_to_steps(x_rev) if x_rev is not None else None
-        y_steps = self.revolutions_to_steps(y_rev) if y_rev is not None else None
-        z_steps = self.revolutions_to_steps(z_rev) if z_rev is not None else None
-        
-        return self.move_xyz(x_steps, y_steps, z_steps, speed, acceleration)
-    
-    def move_to_position_degrees(self, axis: MotorAxis, degrees: float, speed: int = 5000, 
-                               acceleration: int = 1000, precision: int = 100) -> bool:
-        """
-        使用角度值移动单个轴到指定位置
-        
-        Args:
-            axis: 电机轴
-            degrees: 目标角度（度）
-            speed: 移动速度
-            acceleration: 加速度
-            precision: 精度
-            
-        Returns:
-            移动操作是否成功
-        """
-        steps = self.degrees_to_steps(degrees)
-        return self.move_to_position(axis, steps, speed, acceleration, precision)
-    
-    def move_to_position_revolutions(self, axis: MotorAxis, revolutions: float, speed: int = 5000, 
-                                   acceleration: int = 1000, precision: int = 100) -> bool:
-        """
-        使用圈数值移动单个轴到指定位置
-        
-        Args:
-            axis: 电机轴
-            revolutions: 目标圈数
-            speed: 移动速度
-            acceleration: 加速度
-            precision: 精度
-            
-        Returns:
-            移动操作是否成功
-        """
-        steps = self.revolutions_to_steps(revolutions)
-        return self.move_to_position(axis, steps, speed, acceleration, precision)
-    
-    def stop_all_axes(self) -> Dict[MotorAxis, bool]:
-        """
-        紧急停止所有轴
-        
-        Returns:
-            各轴停止结果字典
-        """
-        results = {}
-        for axis in MotorAxis:
-            results[axis] = self.emergency_stop(axis)
-        return results
-    
-    def enable_all_axes(self, enable: bool = True) -> Dict[MotorAxis, bool]:
-        """
-        使能/失能所有轴
-        
-        Args:
-            enable: True为使能，False为失能
-            
-        Returns:
-            各轴操作结果字典
-        """
-        results = {}
-        for axis in MotorAxis:
-            results[axis] = self.enable_motor(axis, enable)
-        return results
-    
-    def get_all_positions(self) -> Dict[MotorAxis, MotorPosition]:
-        """
-        获取所有轴的位置信息
-        
-        Returns:
-            各轴位置信息字典
-        """
-        positions = {}
-        for axis in MotorAxis:
-            positions[axis] = self.get_motor_status(axis)
-        return positions
-    
-    def home_all_axes(self) -> Dict[MotorAxis, bool]:
-        """
-        所有轴归零
-        
-        Returns:
-            各轴归零结果字典
-        """
-        results = {}
-        for axis in MotorAxis:
-            results[axis] = self.home_axis(axis)
-        return results
--- a/unilabos/devices/laiyu_liquid/tests/init.py
+++ b/unilabos/devices/laiyu_liquid/tests/init.py
@@ -1,13 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-LaiYu液体处理设备测试模块
-
-该模块包含LaiYu液体处理设备的测试用例：
- test_deck_config.py: 工作台配置测试
-
-作者: UniLab团队
-版本: 2.0.0
-"""
-
-__all__ = []
--- a/unilabos/devices/laiyu_liquid/tests/test_deck_config.py
+++ b/unilabos/devices/laiyu_liquid/tests/test_deck_config.py
@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-测试脚本：验证更新后的deck配置是否正常工作
-"""
-
-import sys
-import os
-import json
-
-# 添加项目根目录到Python路径
-project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-sys.path.insert(0, project_root)
-
-def test_config_loading():
-    """测试配置文件加载功能"""
-    print("=" * 50)
-    print("测试配置文件加载功能")
-    print("=" * 50)
-    
-    try:
-        # 直接测试配置文件加载
-        config_path = os.path.join(os.path.dirname(__file__), "controllers", "deckconfig.json")
-        fallback_path = os.path.join(os.path.dirname(__file__), "config", "deck.json")
-        
-        config = None
-        config_source = ""
-        
-        if os.path.exists(config_path):
-            with open(config_path, 'r', encoding='utf-8') as f:
-                config = json.load(f)
-            config_source = "config/deckconfig.json"
-        elif os.path.exists(fallback_path):
-            with open(fallback_path, 'r', encoding='utf-8') as f:
-                config = json.load(f)
-            config_source = "config/deck.json"
-        else:
-            print("❌ 配置文件不存在")
-            return False
-        
-        print(f"✅ 配置文件加载成功: {config_source}")
-        print(f"   - 甲板尺寸: {config.get('size_x', 'N/A')} x {config.get('size_y', 'N/A')} x {config.get('size_z', 'N/A')}")
-        print(f"   - 子模块数量: {len(config.get('children', []))}")
-        
-        # 检查各个模块是否存在
-        modules = config.get('children', [])
-        module_types = [module.get('type') for module in modules]
-        module_names = [module.get('name') for module in modules]
-        
-        print(f"   - 模块类型: {', '.join(set(filter(None, module_types)))}")
-        print(f"   - 模块名称: {', '.join(filter(None, module_names))}")
-        
-        return config
-    except Exception as e:
-        print(f"❌ 配置文件加载失败: {e}")
-        return None
-
-def test_module_coordinates(config):
-    """测试各模块的坐标信息"""
-    print("\n" + "=" * 50)
-    print("测试模块坐标信息")
-    print("=" * 50)
-    
-    if not config:
-        print("❌ 配置为空，无法测试")
-        return False
-    
-    modules = config.get('children', [])
-    
-    for module in modules:
-        module_name = module.get('name', '未知模块')
-        module_type = module.get('type', '未知类型')
-        position = module.get('position', {})
-        size = module.get('size', {})
-        
-        print(f"\n模块: {module_name} ({module_type})")
-        print(f"   - 位置: ({position.get('x', 0)}, {position.get('y', 0)}, {position.get('z', 0)})")
-        print(f"   - 尺寸: {size.get('x', 0)} x {size.get('y', 0)} x {size.get('z', 0)}")
-        
-        # 检查孔位信息
-        wells = module.get('wells', [])
-        if wells:
-            print(f"   - 孔位数量: {len(wells)}")
-            
-            # 显示前几个和后几个孔位的坐标
-            sample_wells = wells[:3] + wells[-3:] if len(wells) > 6 else wells
-            for well in sample_wells:
-                well_id = well.get('id', '未知')
-                well_pos = well.get('position', {})
-                print(f"     {well_id}: ({well_pos.get('x', 0)}, {well_pos.get('y', 0)}, {well_pos.get('z', 0)})")
-        else:
-            print(f"   - 无孔位信息")
-    
-    return True
-
-def test_coordinate_ranges(config):
-    """测试坐标范围的合理性"""
-    print("\n" + "=" * 50)
-    print("测试坐标范围合理性")
-    print("=" * 50)
-    
-    if not config:
-        print("❌ 配置为空，无法测试")
-        return False
-    
-    deck_size = {
-        'x': config.get('size_x', 340),
-        'y': config.get('size_y', 250),
-        'z': config.get('size_z', 160)
-    }
-    
-    print(f"甲板尺寸: {deck_size['x']} x {deck_size['y']} x {deck_size['z']}")
-    
-    modules = config.get('children', [])
-    all_coordinates = []
-    
-    for module in modules:
-        module_name = module.get('name', '未知模块')
-        wells = module.get('wells', [])
-        
-        for well in wells:
-            well_pos = well.get('position', {})
-            x, y, z = well_pos.get('x', 0), well_pos.get('y', 0), well_pos.get('z', 0)
-            all_coordinates.append((x, y, z, f"{module_name}:{well.get('id', '未知')}"))
-    
-    if not all_coordinates:
-        print("❌ 没有找到任何坐标信息")
-        return False
-    
-    # 计算坐标范围
-    x_coords = [coord[0] for coord in all_coordinates]
-    y_coords = [coord[1] for coord in all_coordinates]
-    z_coords = [coord[2] for coord in all_coordinates]
-    
-    x_range = (min(x_coords), max(x_coords))
-    y_range = (min(y_coords), max(y_coords))
-    z_range = (min(z_coords), max(z_coords))
-    
-    print(f"X坐标范围: {x_range[0]:.2f} ~ {x_range[1]:.2f}")
-    print(f"Y坐标范围: {y_range[0]:.2f} ~ {y_range[1]:.2f}")
-    print(f"Z坐标范围: {z_range[0]:.2f} ~ {z_range[1]:.2f}")
-    
-    # 检查是否超出甲板范围
-    issues = []
-    if x_range[1] > deck_size['x']:
-        issues.append(f"X坐标超出甲板范围: {x_range[1]} > {deck_size['x']}")
-    if y_range[1] > deck_size['y']:
-        issues.append(f"Y坐标超出甲板范围: {y_range[1]} > {deck_size['y']}")
-    if z_range[1] > deck_size['z']:
-        issues.append(f"Z坐标超出甲板范围: {z_range[1]} > {deck_size['z']}")
-    
-    if x_range[0] < 0:
-        issues.append(f"X坐标为负值: {x_range[0]}")
-    if y_range[0] < 0:
-        issues.append(f"Y坐标为负值: {y_range[0]}")
-    if z_range[0] < 0:
-        issues.append(f"Z坐标为负值: {z_range[0]}")
-    
-    if issues:
-        print("⚠️  发现坐标问题:")
-        for issue in issues:
-            print(f"   - {issue}")
-        return False
-    else:
-        print("✅ 所有坐标都在合理范围内")
-        return True
-
-def test_well_spacing(config):
-    """测试孔位间距的一致性"""
-    print("\n" + "=" * 50)
-    print("测试孔位间距一致性")
-    print("=" * 50)
-    
-    if not config:
-        print("❌ 配置为空，无法测试")
-        return False
-    
-    modules = config.get('children', [])
-    
-    for module in modules:
-        module_name = module.get('name', '未知模块')
-        module_type = module.get('type', '未知类型')
-        wells = module.get('wells', [])
-        
-        if len(wells) < 2:
-            continue
-        
-        print(f"\n模块: {module_name} ({module_type})")
-        
-        # 计算相邻孔位的间距
-        spacings_x = []
-        spacings_y = []
-        
-        # 按行列排序孔位
-        wells_by_row = {}
-        for well in wells:
-            well_id = well.get('id', '')
-            if len(well_id) >= 3:  # 如A01格式
-                row = well_id[0]
-                col = int(well_id[1:])
-                if row not in wells_by_row:
-                    wells_by_row[row] = {}
-                wells_by_row[row][col] = well
-        
-        # 计算同行相邻孔位的X间距
-        for row, cols in wells_by_row.items():
-            sorted_cols = sorted(cols.keys())
-            for i in range(len(sorted_cols) - 1):
-                col1, col2 = sorted_cols[i], sorted_cols[i + 1]
-                if col2 == col1 + 1:  # 相邻列
-                    pos1 = cols[col1].get('position', {})
-                    pos2 = cols[col2].get('position', {})
-                    spacing = abs(pos2.get('x', 0) - pos1.get('x', 0))
-                    spacings_x.append(spacing)
-        
-        # 计算同列相邻孔位的Y间距
-        cols_by_row = {}
-        for well in wells:
-            well_id = well.get('id', '')
-            if len(well_id) >= 3:
-                row = ord(well_id[0]) - ord('A')
-                col = int(well_id[1:])
-                if col not in cols_by_row:
-                    cols_by_row[col] = {}
-                cols_by_row[col][row] = well
-        
-        for col, rows in cols_by_row.items():
-            sorted_rows = sorted(rows.keys())
-            for i in range(len(sorted_rows) - 1):
-                row1, row2 = sorted_rows[i], sorted_rows[i + 1]
-                if row2 == row1 + 1:  # 相邻行
-                    pos1 = rows[row1].get('position', {})
-                    pos2 = rows[row2].get('position', {})
-                    spacing = abs(pos2.get('y', 0) - pos1.get('y', 0))
-                    spacings_y.append(spacing)
-        
-        # 检查间距一致性
-        if spacings_x:
-            avg_x = sum(spacings_x) / len(spacings_x)
-            max_diff_x = max(abs(s - avg_x) for s in spacings_x)
-            print(f"   - X方向平均间距: {avg_x:.2f}mm, 最大偏差: {max_diff_x:.2f}mm")
-            
-        if spacings_y:
-            avg_y = sum(spacings_y) / len(spacings_y)
-            max_diff_y = max(abs(s - avg_y) for s in spacings_y)
-            print(f"   - Y方向平均间距: {avg_y:.2f}mm, 最大偏差: {max_diff_y:.2f}mm")
-    
-    return True
-
-def main():
-    """主测试函数"""
-    print("LaiYu液体处理设备配置测试")
-    print("测试时间:", os.popen('date').read().strip())
-    
-    # 运行所有测试
-    tests = [
-        ("配置文件加载", test_config_loading),
-    ]
-    
-    config = None
-    results = []
-    
-    for test_name, test_func in tests:
-        try:
-            if test_name == "配置文件加载":
-                result = test_func()
-                config = result if result else None
-                results.append((test_name, bool(result)))
-            else:
-                result = test_func(config)
-                results.append((test_name, result))
-        except Exception as e:
-            print(f"❌ 测试 {test_name} 执行失败: {e}")
-            results.append((test_name, False))
-    
-    # 如果配置加载成功，运行其他测试
-    if config:
-        additional_tests = [
-            ("模块坐标信息", test_module_coordinates),
-            ("坐标范围合理性", test_coordinate_ranges),
-            ("孔位间距一致性", test_well_spacing)
-        ]
-        
-        for test_name, test_func in additional_tests:
-            try:
-                result = test_func(config)
-                results.append((test_name, result))
-            except Exception as e:
-                print(f"❌ 测试 {test_name} 执行失败: {e}")
-                results.append((test_name, False))
-    
-    # 输出测试总结
-    print("\n" + "=" * 50)
-    print("测试总结")
-    print("=" * 50)
-    
-    passed = sum(1 for _, result in results if result)
-    total = len(results)
-    
-    for test_name, result in results:
-        status = "✅ 通过" if result else "❌ 失败"
-        print(f"   {test_name}: {status}")
-    
-    print(f"\n总计: {passed}/{total} 个测试通过")
-    
-    if passed == total:
-        print("🎉 所有测试通过！配置更新成功。")
-        return True
-    else:
-        print("⚠️  部分测试失败，需要进一步检查。")
-        return False
-
-if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1)
--- a/unilabos/devices/liquid_handling/liquid_handler_abstract.py
+++ b/unilabos/devices/liquid_handling/liquid_handler_abstract.py
@@ -923,7 +923,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
        spread: Literal["wide", "tight", "custom"] = "wide",
        is_96_well: bool = False,
        mix_stage: Optional[Literal["none", "before", "after", "both"]] = "none",
-        mix_times: Optional[int] = None,
+        mix_times: Optional[List[int]] = None,
        mix_vol: Optional[int] = None,
        mix_rate: Optional[int] = None,
        mix_liquid_height: Optional[float] = None,
--- a/unilabos/devices/liquid_handling/prcxi/prcxi.py
+++ b/unilabos/devices/liquid_handling/prcxi/prcxi.py
@@ -2,7 +2,6 @@ import asyncio
 import collections
 import contextlib
 import json
-import os
 import socket
 import time
 from typing import Any, List, Dict, Optional, Tuple, TypedDict, Union, Sequence, Iterator, Literal
@@ -549,7 +548,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
            blending_times=0,
            balance_height=0,
            plate_or_hole=f"H{hole_col}-8,T{PlateNo}",
-            hole_numbers=f"{(hole_col - 1) * 8 + hole_row}" if self._num_channels == 1 else "1,2,3,4,5",
+            hole_numbers="1,2,3,4,5,6,7,8",
        )
        self.steps_todo_list.append(step)

@@ -1619,39 +1618,24 @@ if __name__ == "__main__":
        host="192.168.0.121",
        port=9999,
        timeout=10.0,
-        setup=True,
+        setup=False,
        debug=False,
        matrix_id="5de524d0-3f95-406c-86dd-f83626ebc7cb",
        channel_num=1,
-        axis="Right",
+        axis="Left",
        simulator=False,
        is_9320=True,
-    )
+    )  # Initialize the handler with the deck and host settings
    backend: PRCXI9300Backend = handler.backend
-    from pylabrobot.resources import set_volume_tracking
-    set_volume_tracking(enabled=True)
-    # res = backend.api_client.get_all_materials()
+    res = backend.api_client.get_all_materials()
+    handler.set_tiprack([plate8])  # Set the tip rack for the handler
    asyncio.run(handler.setup())  # Initialize the handler and setup the connection
-    handler.set_tiprack([plate1, plate5])  # Set the tip rack for the handler
-    handler.set_liquid([plate9.get_well("H12")], ["water"], [5])
-    asyncio.run(handler.create_protocol(protocol_name="Test Protocol"))
-    asyncio.run(handler.pick_up_tips([plate5.get_item("C5")], [0]))
-    asyncio.run(handler.aspirate([plate9.get_item("H12")], [5], [0]))
+    from pylabrobot.resources import set_volume_tracking
+
+    # from pylabrobot.resources import set_tip_tracking
+    set_volume_tracking(enabled=True)
+

-    for well in plate13.get_all_items():
-        # well_pos = well.name.split("_")[1]       # 走一行
-        # if well_pos.startswith("A"):             
-        if well.name.startswith("PlateT13"):       # 走整个Plate
-            asyncio.run(handler.dispense([well], [0.01], [0]))
-        
-    # asyncio.run(handler.dispense([plate10.get_item("H12")], [1], [0]))
-    # asyncio.run(handler.dispense([plate13.get_item("A1")], [1], [0]))
-    # asyncio.run(handler.dispense([plate14.get_item("C5")], [1], [0]))
-    asyncio.run(handler.mix([plate10.get_item("H12")], mix_time=3, mix_vol=5))
-    asyncio.run(handler.discard_tips([0]))
-    asyncio.run(handler.run_protocol())
-    time.sleep(5)
-    os._exit(0)
 # 第一种情景：一个孔往多个孔加液
    # plate_2_liquids = handler.set_group("water", [plate2.children[0]], [300])
    # plate5_liquids = handler.set_group("master_mix", plate5.children[:23], [100]*23)
@@ -1668,7 +1652,7 @@ if __name__ == "__main__":
 #     #     json.dump(A, f, indent=4, ensure_ascii=False)

 #     print(plate11.get_well(0).tracker.get_used_volume())
-     # Initialize the backend and setup the connection
+    asyncio.run(handler.create_protocol(protocol_name="Test Protocol"))  # Initialize the backend and setup the connection
    asyncio.run(handler.transfer_group("water", "master_mix", 10))  # Reset tip tracking


--- a/unilabos/devices/liquid_handling/rviz_backend.py
+++ b/unilabos/devices/liquid_handling/rviz_backend.py
@@ -1,304 +0,0 @@
-      
-import json
-from typing import List, Optional, Union
-
-from pylabrobot.liquid_handling.backends.backend import (
-  LiquidHandlerBackend,
-)
-from pylabrobot.liquid_handling.standard import (
-  Drop,
-  DropTipRack,
-  MultiHeadAspirationContainer,
-  MultiHeadAspirationPlate,
-  MultiHeadDispenseContainer,
-  MultiHeadDispensePlate,
-  Pickup,
-  PickupTipRack,
-  ResourceDrop,
-  ResourceMove,
-  ResourcePickup,
-  SingleChannelAspiration,
-  SingleChannelDispense,
-)
-from pylabrobot.resources import Resource, Tip
-
-import rclpy
-from rclpy.node import Node
-from sensor_msgs.msg import JointState
-import time
-from rclpy.action import ActionClient
-from unilabos_msgs.action import SendCmd
-import re
-
-from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
-
-
-class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
-  """Chatter box backend for device-free testing. Prints out all operations."""
-
-  _pip_length = 5
-  _vol_length = 8
-  _resource_length = 20
-  _offset_length = 16
-  _flow_rate_length = 10
-  _blowout_length = 10
-  _lld_z_length = 10
-  _kwargs_length = 15
-  _tip_type_length = 12
-  _max_volume_length = 16
-  _fitting_depth_length = 20
-  _tip_length_length = 16
-  # _pickup_method_length = 20
-  _filter_length = 10
-
-  def __init__(self, num_channels: int = 8 , tip_length: float = 0 , total_height: float = 310):
-    """Initialize a chatter box backend."""
-    super().__init__()
-    self._num_channels = num_channels
-    self.tip_length = tip_length
-    self.total_height = total_height
-# rclpy.init()
-    if not rclpy.ok():
-        rclpy.init()
-    self.joint_state_publisher = None
-
-  async def setup(self):
-    self.joint_state_publisher = JointStatePublisher()
-    await super().setup()
-
-    print("Setting up the liquid handler.")
-
-  async def stop(self):
-    print("Stopping the liquid handler.")
-
-  def serialize(self) -> dict:
-    return {**super().serialize(), "num_channels": self.num_channels}
-
-  @property
-  def num_channels(self) -> int:
-    return self._num_channels
-
-  async def assigned_resource_callback(self, resource: Resource):
-    print(f"Resource {resource.name} was assigned to the liquid handler.")
-
-  async def unassigned_resource_callback(self, name: str):
-    print(f"Resource {name} was unassigned from the liquid handler.")
-
-  async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int], **backend_kwargs):
-    print("Picking up tips:")
-    # print(ops.tip)
-    header = (
-      f"{'pip#':<{UniLiquidHandlerRvizBackend._pip_length}} "
-      f"{'resource':<{UniLiquidHandlerRvizBackend._resource_length}} "
-      f"{'offset':<{UniLiquidHandlerRvizBackend._offset_length}} "
-      f"{'tip type':<{UniLiquidHandlerRvizBackend._tip_type_length}} "
-      f"{'max volume (µL)':<{UniLiquidHandlerRvizBackend._max_volume_length}} "
-      f"{'fitting depth (mm)':<{UniLiquidHandlerRvizBackend._fitting_depth_length}} "
-      f"{'tip length (mm)':<{UniLiquidHandlerRvizBackend._tip_length_length}} "
-      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
-      f"{'filter':<{UniLiquidHandlerRvizBackend._filter_length}}"
-    )
-    # print(header)
-
-    for op, channel in zip(ops, use_channels):
-      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
-      row = (
-        f"  p{channel}: "
-        f"{op.resource.name[-30:]:<{UniLiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{UniLiquidHandlerRvizBackend._offset_length}} "
-        f"{op.tip.__class__.__name__:<{UniLiquidHandlerRvizBackend._tip_type_length}} "
-        f"{op.tip.maximal_volume:<{UniLiquidHandlerRvizBackend._max_volume_length}} "
-        f"{op.tip.fitting_depth:<{UniLiquidHandlerRvizBackend._fitting_depth_length}} "
-        f"{op.tip.total_tip_length:<{UniLiquidHandlerRvizBackend._tip_length_length}} "
-        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
-        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerRvizBackend._filter_length}}"
-      )
-      # print(row)
-      # print(op.resource.get_absolute_location())
-    
-    self.tip_length = ops[0].tip.total_tip_length
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    offset_xyz = ops[0].offset
-    x = coordinate.x + offset_xyz.x
-    y = coordinate.y + offset_xyz.y
-    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
-    # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "pick",channels=use_channels)
-    #   goback()
-
-
-
-
-  async def drop_tips(self, ops: List[Drop], use_channels: List[int], **backend_kwargs):
-    print("Dropping tips:")
-    header = (
-      f"{'pip#':<{UniLiquidHandlerRvizBackend._pip_length}} "
-      f"{'resource':<{UniLiquidHandlerRvizBackend._resource_length}} "
-      f"{'offset':<{UniLiquidHandlerRvizBackend._offset_length}} "
-      f"{'tip type':<{UniLiquidHandlerRvizBackend._tip_type_length}} "
-      f"{'max volume (µL)':<{UniLiquidHandlerRvizBackend._max_volume_length}} "
-      f"{'fitting depth (mm)':<{UniLiquidHandlerRvizBackend._fitting_depth_length}} "
-      f"{'tip length (mm)':<{UniLiquidHandlerRvizBackend._tip_length_length}} "
-      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
-      f"{'filter':<{UniLiquidHandlerRvizBackend._filter_length}}"
-    )
-    # print(header)
-
-    for op, channel in zip(ops, use_channels):
-      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
-      row = (
-        f"  p{channel}: "
-        f"{op.resource.name[-30:]:<{UniLiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{UniLiquidHandlerRvizBackend._offset_length}} "
-        f"{op.tip.__class__.__name__:<{UniLiquidHandlerRvizBackend._tip_type_length}} "
-        f"{op.tip.maximal_volume:<{UniLiquidHandlerRvizBackend._max_volume_length}} "
-        f"{op.tip.fitting_depth:<{UniLiquidHandlerRvizBackend._fitting_depth_length}} "
-        f"{op.tip.total_tip_length:<{UniLiquidHandlerRvizBackend._tip_length_length}} "
-        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
-        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerRvizBackend._filter_length}}"
-      )
-      # print(row)
-
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    offset_xyz = ops[0].offset
-    x = coordinate.x + offset_xyz.x
-    y = coordinate.y + offset_xyz.y
-    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
-    # print(x, y, z)
-    # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "drop_trash",channels=use_channels)
-    #   goback()
-
-  async def aspirate(
-    self,
-    ops: List[SingleChannelAspiration],
-    use_channels: List[int],
-    **backend_kwargs,
-  ):
-    print("Aspirating:")
-    header = (
-      f"{'pip#':<{UniLiquidHandlerRvizBackend._pip_length}} "
-      f"{'vol(ul)':<{UniLiquidHandlerRvizBackend._vol_length}} "
-      f"{'resource':<{UniLiquidHandlerRvizBackend._resource_length}} "
-      f"{'offset':<{UniLiquidHandlerRvizBackend._offset_length}} "
-      f"{'flow rate':<{UniLiquidHandlerRvizBackend._flow_rate_length}} "
-      f"{'blowout':<{UniLiquidHandlerRvizBackend._blowout_length}} "
-      f"{'lld_z':<{UniLiquidHandlerRvizBackend._lld_z_length}}  "
-      # f"{'liquids':<20}" # TODO: add liquids
-    )
-    for key in backend_kwargs:
-      header += f"{key:<{UniLiquidHandlerRvizBackend._kwargs_length}} "[-16:]
-    # print(header)
-
-    for o, p in zip(ops, use_channels):
-      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
-      row = (
-        f"  p{p}: "
-        f"{o.volume:<{UniLiquidHandlerRvizBackend._vol_length}} "
-        f"{o.resource.name[-20:]:<{UniLiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{UniLiquidHandlerRvizBackend._offset_length}} "
-        f"{str(o.flow_rate):<{UniLiquidHandlerRvizBackend._flow_rate_length}} "
-        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerRvizBackend._blowout_length}} "
-        f"{str(o.liquid_height):<{UniLiquidHandlerRvizBackend._lld_z_length}} "
-        # f"{o.liquids if o.liquids is not None else 'none'}"
-      )
-      for key, value in backend_kwargs.items():
-        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
-          value = "".join("T" if v else "F" for v in value)
-        if isinstance(value, list):
-          value = "".join(map(str, value))
-        row += f" {value:<15}"
-      # print(row)
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    offset_xyz = ops[0].offset
-    x = coordinate.x + offset_xyz.x
-    y = coordinate.y + offset_xyz.y
-    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
-    # print(x, y, z)
-    # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
-
-
-  async def dispense(
-    self,
-    ops: List[SingleChannelDispense],
-    use_channels: List[int],
-    **backend_kwargs,
-  ):
-    # print("Dispensing:")
-    header = (
-      f"{'pip#':<{UniLiquidHandlerRvizBackend._pip_length}} "
-      f"{'vol(ul)':<{UniLiquidHandlerRvizBackend._vol_length}} "
-      f"{'resource':<{UniLiquidHandlerRvizBackend._resource_length}} "
-      f"{'offset':<{UniLiquidHandlerRvizBackend._offset_length}} "
-      f"{'flow rate':<{UniLiquidHandlerRvizBackend._flow_rate_length}} "
-      f"{'blowout':<{UniLiquidHandlerRvizBackend._blowout_length}} "
-      f"{'lld_z':<{UniLiquidHandlerRvizBackend._lld_z_length}}  "
-      # f"{'liquids':<20}" # TODO: add liquids
-    )
-    for key in backend_kwargs:
-      header += f"{key:<{UniLiquidHandlerRvizBackend._kwargs_length}} "[-16:]
-    # print(header)
-
-    for o, p in zip(ops, use_channels):
-      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
-      row = (
-        f"  p{p}: "
-        f"{o.volume:<{UniLiquidHandlerRvizBackend._vol_length}} "
-        f"{o.resource.name[-20:]:<{UniLiquidHandlerRvizBackend._resource_length}} "
-        f"{offset:<{UniLiquidHandlerRvizBackend._offset_length}} "
-        f"{str(o.flow_rate):<{UniLiquidHandlerRvizBackend._flow_rate_length}} "
-        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerRvizBackend._blowout_length}} "
-        f"{str(o.liquid_height):<{UniLiquidHandlerRvizBackend._lld_z_length}} "
-        # f"{o.liquids if o.liquids is not None else 'none'}"
-      )
-      for key, value in backend_kwargs.items():
-        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
-          value = "".join("T" if v else "F" for v in value)
-        if isinstance(value, list):
-          value = "".join(map(str, value))
-        row += f" {value:<{UniLiquidHandlerRvizBackend._kwargs_length}}"
-      # print(row)
-    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
-    offset_xyz = ops[0].offset
-    x = coordinate.x + offset_xyz.x
-    y = coordinate.y + offset_xyz.y
-    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
-    # print(x, y, z)
-    # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
-
-  async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
-    print(f"Picking up tips from {pickup.resource.name}.")
-
-  async def drop_tips96(self, drop: DropTipRack, **backend_kwargs):
-    print(f"Dropping tips to {drop.resource.name}.")
-
-  async def aspirate96(
-    self, aspiration: Union[MultiHeadAspirationPlate, MultiHeadAspirationContainer]
-  ):
-    if isinstance(aspiration, MultiHeadAspirationPlate):
-      resource = aspiration.wells[0].parent
-    else:
-      resource = aspiration.container
-    print(f"Aspirating {aspiration.volume} from {resource}.")
-
-  async def dispense96(self, dispense: Union[MultiHeadDispensePlate, MultiHeadDispenseContainer]):
-    if isinstance(dispense, MultiHeadDispensePlate):
-      resource = dispense.wells[0].parent
-    else:
-      resource = dispense.container
-    print(f"Dispensing {dispense.volume} to {resource}.")
-
-  async def pick_up_resource(self, pickup: ResourcePickup):
-    print(f"Picking up resource: {pickup}")
-
-  async def move_picked_up_resource(self, move: ResourceMove):
-    print(f"Moving picked up resource: {move}")
-
-  async def drop_resource(self, drop: ResourceDrop):
-    print(f"Dropping resource: {drop}")
-
-  def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
-    return True
-    
--- a/unilabos/devices/workstation/bioyond_cell/2025092702.xlsx
+++ b/unilabos/devices/workstation/bioyond_cell/2025092702.xlsx
--- a/unilabos/devices/workstation/bioyond_cell/2025101301.xlsx
+++ b/unilabos/devices/workstation/bioyond_cell/2025101301.xlsx
--- a/unilabos/devices/workstation/bioyond_cell/benyao_test.py
+++ b/unilabos/devices/workstation/bioyond_cell/benyao_test.py
@@ -0,0 +1,49 @@
+import requests
+import json
+from datetime import datetime
+def test_benyao_api():
+    # 配置信息
+    ip_addr = "192.168.1.200"
+    port = 44386
+    #url = f"http://{ip_addr}:{port}/api/lims/scheduler/scheduler-status"
+    #url = f"http://{ip_addr}:{port}/api/lims/order/order-list-status"
+    url = f"http://{ip_addr}:{port}/api/lims/storage/stock-material"
+    apiKey = "8A819E5C"  # 请替换为实际apiKey
+    
+    # 构造请求体
+    request_data = {
+        "apiKey": apiKey,
+        "requestTime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),  # 示例：2025-08-15T10:00:00.000Z
+        "data": {
+                "typeMode": 1,
+                "includeDetail": True
+            }
+    
+    }
+    
+    #request_data = {
+    #    "apiKey": apiKey,
+    #    "requestTime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),  # 示例：2025-08-15T10:00:00.000Z
+    #    "data": 
+    #}
+    
+    
+    print(request_data)
+    # 发送POST请求
+    try:
+        response = requests.post(url, json=request_data, timeout=10)
+        response.raise_for_status()  # 检查HTTP状态码
+    
+        # 解析响应
+        result = response.json()
+        print("响应状态码:", response.status_code)
+        print("响应内容:")
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    
+    except requests.exceptions.RequestException as e:
+        print("请求失败:", e)
+    except json.JSONDecodeError as e:
+        print("JSON解析失败:", e)
+    
+if __name__ == "__main__":
+    test_benyao_api()
--- a/unilabos/devices/workstation/bioyond_cell/bioyond_material_management.py
+++ b/unilabos/devices/workstation/bioyond_cell/bioyond_material_management.py
@@ -0,0 +1,374 @@
+"""
+Bioyond物料管理实现
+Bioyond Material Management Implementation
+
+基于Bioyond系统的物料管理，支持从Bioyond系统同步物料到UniLab工作站
+"""
+from typing import Dict, Any, List, Optional, Union
+import json
+import asyncio
+from abc import ABC, abstractmethod
+
+from pylabrobot.resources import (
+    Resource as PLRResource,
+    Container,
+    Deck,
+    Coordinate as PLRCoordinate,
+)
+
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
+from unilabos.utils.log import logger
+from unilabos.resources.graphio import (
+    resource_plr_to_ulab, 
+    resource_ulab_to_plr,
+    resource_bioyond_to_ulab,
+    resource_bioyond_container_to_ulab,
+    resource_ulab_to_bioyond
+)
+from .workstation_material_management import MaterialManagementBase
+
+
+class BioyondMaterialManagement(MaterialManagementBase):
+    """Bioyond物料管理类
+    
+    实现从Bioyond系统同步物料到UniLab工作站的功能：
+    1. 从Bioyond系统获取物料数据
+    2. 转换为UniLab格式
+    3. 同步到PyLabRobot Deck
+    4. 支持双向同步
+    """
+    
+    def __init__(
+        self,
+        device_id: str,
+        deck_config: Dict[str, Any],
+        resource_tracker: DeviceNodeResourceTracker,
+        children_config: Dict[str, Dict[str, Any]] = None,
+        bioyond_config: Dict[str, Any] = None
+    ):
+        self.bioyond_config = bioyond_config or {}
+        self.bioyond_api_client = None
+        self.sync_interval = self.bioyond_config.get("sync_interval", 30)  # 同步间隔（秒）
+        
+        # 初始化父类
+        super().__init__(device_id, deck_config, resource_tracker, children_config)
+        
+        # 初始化Bioyond API客户端
+        self._initialize_bioyond_client()
+        
+        # 启动同步任务
+        self._start_sync_task()
+    
+    def _initialize_bioyond_client(self):
+        """初始化Bioyond API客户端"""
+        try:
+            # 这里应该根据实际的Bioyond API实现
+            # 暂时使用模拟客户端
+            self.bioyond_api_client = BioyondAPIClient(self.bioyond_config)
+            logger.info(f"Bioyond API客户端初始化成功")
+        except Exception as e:
+            logger.error(f"Bioyond API客户端初始化失败: {e}")
+            self.bioyond_api_client = None
+    
+    def _start_sync_task(self):
+        """启动同步任务"""
+        if self.bioyond_api_client:
+            # 创建异步同步任务
+            asyncio.create_task(self._periodic_sync())
+            logger.info(f"Bioyond同步任务已启动，间隔: {self.sync_interval}秒")
+    
+    async def _periodic_sync(self):
+        """定期同步任务"""
+        while True:
+            try:
+                await self.sync_from_bioyond()
+                await asyncio.sleep(self.sync_interval)
+            except Exception as e:
+                logger.error(f"Bioyond同步任务出错: {e}")
+                await asyncio.sleep(self.sync_interval)
+    
+    async def sync_from_bioyond(self) -> bool:
+        """从Bioyond系统同步物料"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 从Bioyond获取物料数据
+            bioyond_data = await self.bioyond_api_client.get_materials()
+            if not bioyond_data:
+                logger.warning("从Bioyond获取物料数据为空")
+                return False
+            
+            # 2. 转换为UniLab格式
+            if isinstance(bioyond_data, dict) and "data" in bioyond_data:
+                # 容器格式数据
+                unilab_resources = resource_bioyond_container_to_ulab(bioyond_data)
+            else:
+                # 物料列表格式数据
+                unilab_resources = resource_bioyond_to_ulab(bioyond_data)
+            
+            # 3. 转换为PLR格式并分配到Deck
+            await self._assign_resources_to_deck(unilab_resources)
+            
+            logger.info(f"从Bioyond同步了 {len(unilab_resources)} 个资源")
+            return True
+            
+        except Exception as e:
+            logger.error(f"从Bioyond同步物料失败: {e}")
+            return False
+    
+    async def sync_to_bioyond(self, plr_resource: PLRResource) -> bool:
+        """将本地物料变更同步到Bioyond系统"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 转换为UniLab格式
+            unilab_resource = resource_plr_to_ulab(plr_resource)
+            
+            # 2. 转换为Bioyond格式
+            bioyond_materials = resource_ulab_to_bioyond([unilab_resource])
+            
+            # 3. 发送到Bioyond系统
+            success = await self.bioyond_api_client.update_materials(bioyond_materials)
+            
+            if success:
+                logger.info(f"成功同步物料 {plr_resource.name} 到Bioyond")
+            else:
+                logger.warning(f"同步物料 {plr_resource.name} 到Bioyond失败")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"同步物料到Bioyond失败: {e}")
+            return False
+    
+    async def _assign_resources_to_deck(self, unilab_resources: List[Dict[str, Any]]):
+        """将UniLab资源分配到Deck"""
+        try:
+            # 转换为PLR格式
+            from unilabos.resources.graphio import list_to_nested_dict
+            nested_resources = list_to_nested_dict(unilab_resources)
+            plr_resources = resource_ulab_to_plr(nested_resources)
+            
+            # 分配资源到Deck
+            if hasattr(plr_resources, 'children'):
+                resources_to_assign = plr_resources.children
+            elif isinstance(plr_resources, list):
+                resources_to_assign = plr_resources
+            else:
+                resources_to_assign = [plr_resources]
+            
+            for resource in resources_to_assign:
+                try:
+                    # 获取资源位置
+                    if hasattr(resource, 'location') and resource.location:
+                        location = PLRCoordinate(resource.location.x, resource.location.y, resource.location.z)
+                    else:
+                        location = PLRCoordinate(0, 0, 0)
+                    
+                    # 分配资源到Deck
+                    self.plr_deck.assign_child_resource(resource, location)
+                    
+                    # 注册到resource tracker
+                    self.resource_tracker.add_resource(resource)
+                    
+                    # 保存资源引用
+                    self.plr_resources[resource.name] = resource
+                    
+                except Exception as e:
+                    logger.error(f"分配资源 {resource.name} 到Deck失败: {e}")
+            
+            logger.info(f"成功分配了 {len(resources_to_assign)} 个资源到Deck")
+            
+        except Exception as e:
+            logger.error(f"分配资源到Deck失败: {e}")
+    
+    def _create_resource_by_type(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """根据类型创建Bioyond相关资源"""
+        try:
+            # 这里可以根据需要实现特定的Bioyond资源类型
+            # 目前使用通用的容器类型
+            if resource_type in ["container", "plate", "well"]:
+                return self._create_generic_container(resource_id, resource_type, config, data, location)
+            else:
+                logger.warning(f"未知的Bioyond资源类型: {resource_type}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"创建Bioyond资源失败 {resource_id} ({resource_type}): {e}")
+            return None
+    
+    def _create_generic_container(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """创建通用容器资源"""
+        try:
+            from pylabrobot.resources import Plate, Well
+            
+            if resource_type == "plate":
+                return Plate(
+                    name=resource_id,
+                    size_x=config.get("size_x", 127.76),
+                    size_y=config.get("size_y", 85.48),
+                    size_z=config.get("size_z", 14.35),
+                    location=location,
+                    category="plate"
+                )
+            elif resource_type == "well":
+                return Well(
+                    name=resource_id,
+                    size_x=config.get("size_x", 9.0),
+                    size_y=config.get("size_y", 9.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="well"
+                )
+            else:
+                return Container(
+                    name=resource_id,
+                    size_x=config.get("size_x", 50.0),
+                    size_y=config.get("size_y", 50.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="container"
+                )
+                
+        except Exception as e:
+            logger.error(f"创建通用容器失败 {resource_id}: {e}")
+            return None
+    
+    def get_bioyond_materials(self) -> List[Dict[str, Any]]:
+        """获取当前Bioyond物料列表"""
+        try:
+            # 将当前PLR资源转换为Bioyond格式
+            bioyond_materials = []
+            for resource in self.plr_resources.values():
+                unilab_resource = resource_plr_to_ulab(resource)
+                bioyond_materials.extend(resource_ulab_to_bioyond([unilab_resource]))
+            return bioyond_materials
+        except Exception as e:
+            logger.error(f"获取Bioyond物料列表失败: {e}")
+            return []
+    
+    def update_material_from_bioyond(self, material_id: str, bioyond_data: Dict[str, Any]) -> bool:
+        """从Bioyond数据更新指定物料"""
+        try:
+            # 查找现有物料
+            material = self.find_material_by_id(material_id)
+            if not material:
+                logger.warning(f"未找到物料: {material_id}")
+                return False
+            
+            # 转换Bioyond数据为UniLab格式
+            unilab_resources = resource_bioyond_to_ulab([bioyond_data])
+            if not unilab_resources:
+                logger.warning(f"转换Bioyond数据失败: {material_id}")
+                return False
+            
+            # 更新物料属性
+            unilab_resource = unilab_resources[0]
+            material.name = unilab_resource.get("name", material.name)
+            
+            # 更新位置
+            position = unilab_resource.get("position", {})
+            if position:
+                material.location = PLRCoordinate(
+                    position.get("x", 0),
+                    position.get("y", 0),
+                    position.get("z", 0)
+                )
+            
+            logger.info(f"成功更新物料: {material_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新物料失败 {material_id}: {e}")
+            return False
+
+
+class BioyondAPIClient:
+    """Bioyond API客户端（模拟实现）
+    
+    实际使用时需要根据Bioyond系统的API接口实现
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get("base_url", "http://localhost:8080")
+        self.api_key = config.get("api_key", "")
+        self.timeout = config.get("timeout", 30)
+    
+    async def get_materials(self) -> Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]:
+        """从Bioyond系统获取物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            # 暂时返回模拟数据
+            logger.info("从Bioyond API获取物料数据")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据（实际应该从API获取）
+            return {
+                "data": [],
+                "code": 1,
+                "message": "success",
+                "timestamp": 1234567890
+            }
+            
+        except Exception as e:
+            logger.error(f"Bioyond API调用失败: {e}")
+            return None
+    
+    async def update_materials(self, materials: List[Dict[str, Any]]) -> bool:
+        """更新Bioyond系统中的物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"更新Bioyond系统中的 {len(materials)} 个物料")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 模拟成功响应
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新Bioyond物料失败: {e}")
+            return False
+    
+    async def get_material_by_id(self, material_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取单个物料"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"从Bioyond API获取物料: {material_id}")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据
+            return {
+                "id": material_id,
+                "name": f"material_{material_id}",
+                "type": "container",
+                "quantity": 1.0,
+                "unit": "个"
+            }
+            
+        except Exception as e:
+            logger.error(f"获取Bioyond物料失败 {material_id}: {e}")
+            return None
--- a/unilabos/devices/workstation/bioyond_cell/bioyond_workstation.py
+++ b/unilabos/devices/workstation/bioyond_cell/bioyond_workstation.py
@@ -0,0 +1,796 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+from datetime import datetime, timezone, timedelta
+import re
+import threading
+
+from urllib3 import response
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now()
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,
+        *args, **kwargs,
+    ):
+        default_config = {
+            #"base_url": "http://192.168.1.200:44388",
+            "base_url": "http://61.169.57.196:44422",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+        self.bioyond_config = {**default_config, **(bioyond_config or {})}
+
+        self.http_service_started = False
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+    #     self.order_status = {}
+    #     try:
+    #         t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+    #         t.start()
+
+    #     except Exception as e:
+    #         logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    # @property
+    # def device_id(self) -> str:
+    #     try:
+    #         return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+    #     except Exception:
+    #         return "bioyond_workstation"
+
+    # def _start_http_service_bg(self, host: str = "192.168.1.104", port: int = 8080) -> None:
+    #     logger.info("进入 _start_http_service_bg 函数")
+    #     try:
+    #         self.service = WorkstationHTTPService(self, host=host, port=port)
+    #         logger.info("WorkstationHTTPService 实例化完成")
+    #         self.service.start()
+    #         self.http_service_started = True
+    #         logger.info(f"unilab_HTTP 服务成功启动: {host}:{port}")
+
+    #         一直挂着，直到进程退出
+    #         while True:
+    #             time.sleep(1)
+
+    #     except Exception as e:
+    #         self.http_service_started = False
+    #         logger.error(f"启动unilab_HTTP服务失败: {e}", exc_info=True)
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+
+        if data is not None:
+            payload["data"] = data
+      
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            #print(r.json())
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+        while True:
+            time.sleep(5)
+            response = self._post_lims("/api/lims/order/orders", orders)
+            if response.get("data", []):
+                break
+            logger.info(f"等待配液实验创建完成")
+
+
+       
+        # self.order_status[response["data"]["orderCode"]] = "running"
+
+        # while True:
+        #     time.sleep(5)
+        #     if self.order_status.get(response["data"]["orderCode"], None) == "finished":
+        #         logger.info(f"配液实验已完成 ，即将执行 3-2-1 转运")
+        #         break
+        #     logger.info(f"等待配液实验完成")
+
+        # self.transfer_3_to_2_to_1()
+        # self.wait_for_transfer_task()
+        # logger.info(f"3-2-1 转运完成，返回结果")
+        # return r321
+        return response
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        response = self._post_lims("/api/lims/scheduler/start")
+        print(response)
+        return response
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+            # 2.9 继续调度
+    def scheduler_continue(self) -> Dict[str, Any]:
+        """
+        继续调度 (2.9)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/continue")
+
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+    # 2.5 批量查询实验报告
+    def order_list_v2(self,
+                      timeType: str = "string",
+                      beginTime: str = "",
+                      endTime: str = "",
+                      status: str = "",
+                      filter: str = "",
+                      skipCount: int = 0,
+                      pageCount: int = 1,
+                      sorting: str = "") -> Dict[str, Any]:
+        """
+        批量查询实验报告的详细信息 (2.5)
+        URL: /api/lims/order/order-list
+        参数默认值和接口文档保持一致
+        """
+        data: Dict[str, Any] = {
+            "timeType": timeType,
+            "beginTime": beginTime,
+            "endTime": endTime,
+            "status": status,
+            "filter": filter,
+            "skipCount": skipCount,
+            "pageCount": pageCount,
+            "sorting": sorting
+        }
+        return self._post_lims("/api/lims/order/order-list", data)
+
+        
+    def wait_for_transfer_task(self, timeout: int = 3000, interval: int = 5, filter_text: Optional[str] = None) -> bool:
+        """
+        轮询查询物料转移任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter=filter_text,
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                # 改成用 filter_text 判断
+                if (not filter_text or filter_text in name) and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}, status={status}")
+                    return True
+
+                logger.info(f"等待中: {name}, status={status}")
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的物料转移任务")
+        return False
+    
+
+    def Bioystation_scheduler_start_task(self) -> bool:
+        logger.info("开始调度")
+        self.scheduler_start()
+        logger.info("调度已启动")
+
+    def Bioystation_scheduler_stop_task(self) -> bool:
+        logger.info("停止调度")
+        self.scheduler_stop()
+        logger.info("调度已停止")
+
+    def Bioystation_scheduler_continue_task(self) -> bool:
+        logger.info("继续调度")
+        self.scheduler_continue()
+        logger.info("调度已继续")
+
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    def Bioystation_feeding4to3_from_xlsx_task(self) -> bool:
+        logger.info("4号箱自动上料开始")
+        r1 = self.auto_feeding4to3_from_xlsx(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板.xlsx")
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("4号箱向3号箱转运物料转移任务已完成")
+        return True
+    
+    # # 新建实验
+    def Bioystation_start_experiment_task(self) -> bool:
+        logger.info("3号箱内实验开始")
+        response = self.create_orders(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\2025101301.xlsx")
+        logger.info(response)
+        data_list = response.get("data", [])
+        order_name = data_list[0].get("orderName", "")
+        self.wait_for_transfer_task(filter_text=order_name)
+        logger.info("3号站内实验完成")
+        return True
+
+    def Bioystation_3_to_2_task(self) -> bool:       
+        self.transfer_3_to_2_to_1()
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("3号站向2号站向1号站转移任务完成")
+        return True
+
+    def Bioystation_1_to_2_task(self) -> bool:
+        self.transfer_1_to_2()
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("1号站向2号站转移任务完成")
+        logger.info("全流程结束")
+        return True
+    
+    def test_benyao_workstation(self, num1, num2):
+        num1 = int(num1)
+        num2 = int(num2)
+        for i in range(num1):
+            print(f"num1 = {num1}")
+        for j in range(num2):
+            print(f"num1 = {num2}")        
+
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    #ws.scheduler_stop()
+    #ws.Bioystation_scheduler_start_task()
+    ws.scheduler_start()
+    # ws.scheduler_start()
+    # logger.info("调度启动完成")
+
+    # ws.scheduler_continue()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    # ws.wait_for_transfer_task(filter_text="物料转移任务")
+    # logger.info("4号箱向3号箱转运物料转移任务已完成")
+
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # # 新建实验
+    # response = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092701.xlsx")
+    # logger.info(response)
+    # data_list = response.get("data", [])
+    # order_name = data_list[0].get("orderName", "")
+
+    # ws.wait_for_transfer_task(filter_text=order_name)
+    # ws.wait_for_transfer_task(filter_text='DP20250927001')
+    # logger.info("3号站内实验完成")
+    # # ws.scheduler_start()
+    # # print(res)
+    # ws.transfer_3_to_2_to_1()
+    # ws.wait_for_transfer_task(filter_text="物料转移任务")
+    # logger.info("3号站向2号站向1号站转移任务完成")
+        # r321 = self.wait_for_transfer_task()
+    #1号站启动
+    # ws.transfer_1_to_2()
+    #s.wait_for_transfer_task(filter_text="物料转移任务")
+    #ogger.info("1号站向2号站转移任务完成")
+    #ogger.info("全流程结束")
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])
--- a/unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old
+++ b/unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old
@@ -0,0 +1,772 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+from datetime import datetime, timezone, timedelta
+import re
+import threading
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,   # 增加调试模式开关
+        *args, **kwargs,
+    ):
+        self.bioyond_config = bioyond_config or {
+            #"base_url": "http://192.168.1.200:44386",
+            #"base_url": "http://172.16.11.219:44388",
+            "base_url": "http://61.169.57.196:44422",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+
+
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+        self.order_status = {}
+        try:
+            t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+            t.start()
+
+        except Exception as e:
+            logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    @property
+    def device_id(self) -> str:
+        try:
+            return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+        except Exception:
+            return "bioyond_workstation"
+
+    def _start_http_service_bg(self, host: str = "192.168.1.104", port: int = 7000) -> None:
+        try:
+            self.service = WorkstationHTTPService(self, host=host, port=port)
+            self.service.start()
+
+        except Exception as e:
+            logger.error(f"启动HTTP服务失败: {e}")
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+        if data is not None:
+            payload["data"] = data
+
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+        print("items", items)
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+
+        response = self._post_lims("/api/lims/order/orders", orders)
+        print(response["data"])
+
+        self.order_status[response["data"][0]["orderCode"]] = "running"
+
+        while True:
+            time.sleep(5)
+            if self.order_status.get(response["data"][0]["orderCode"], None) == "finished":
+                break
+        return response
+
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/scheduler/start")
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+            # 2.9 继续调度
+    def scheduler_continue(self) -> Dict[str, Any]:
+        """
+        继续调度 (2.9)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/continue")
+
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+    # 2.5 批量查询实验报告
+    def order_list_v2(self,
+                      timeType: str = "string",
+                      beginTime: str = "",
+                      endTime: str = "",
+                      status: str = "",
+                      filter: str = "物料转移任务",
+                      skipCount: int = 0,
+                      pageCount: int = 1,
+                      sorting: str = "") -> Dict[str, Any]:
+        """
+        批量查询实验报告的详细信息 (2.5)
+        URL: /api/lims/order/order-list
+        参数默认值和接口文档保持一致
+        """
+        data: Dict[str, Any] = {
+            "timeType": timeType,
+            "beginTime": beginTime,
+            "endTime": endTime,
+            "status": status,
+            "filter": filter,
+            "skipCount": skipCount,
+            "pageCount": pageCount,
+            "sorting": sorting
+        }
+        return self._post_lims("/api/lims/order/order-list", data)
+
+        
+    def wait_for_transfer_task(self, timeout: int = 600, interval: int = 3) -> bool:
+        """
+        轮询查询物料转移任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter="物料转移任务",
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                if name.startswith("物料转移任务") and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}")
+                    return True
+
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的物料转移任务")
+        return False
+    
+    def wait_for_recent_task(self, timeout: int = 600, interval: int = 3) -> bool:
+        """
+        轮询查询最近的任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter="",
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                if name.startswith("物料转移任务") and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}")
+                    return True
+
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的任务")
+        return False
+
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    ws.scheduler_stop()
+    ws.scheduler_start()
+    #物料入库
+    r1 = ws.auto_feeding4to3_from_xlsx(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板.xlsx")
+#    print(r1)
+#    print("物料入库任务已提交0")
+#    #等待任务完成
+#    ws.wait_for_transfer_task()
+#
+#    print("物料入库任务已完成1")
+#    
+#    #新建实验
+#    res = ws.create_orders(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\2025092501.xlsx")
+#    print(res)
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+#    print("配液任务已完成")
+#
+#    #新建3-2-1转运任务
+#    r321 = ws.transfer_3_to_2_to_1()
+#    print(r321)
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+#    
+#    ws.transfer_1_to_2()
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+
+
+    #ws._start_http_service_bg()
+    # ws.scheduler_stop()
+    #ws.scheduler_start()
+    # ws.scheduler_continue()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    #ws.wait_for_transfer_task()
+    #print("转运物料转移任务已完成")
+
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # 新建实验
+    # res = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092501.xlsx")
+    # ws.scheduler_start()
+    # print(res)
+    # r321 = ws.transfer_3_to_2_to_1()
+
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])
+    
+    # r321 = ws.transfer_3_to_2_to_1()
+    # ws.transfer_1_to_2()
+
+
--- a/unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old.py
+++ b/unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old.py
@@ -0,0 +1,644 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+import threading
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+from .benyao_test import test_benyao_api
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,   # 增加调试模式开关
+        *args, **kwargs,
+    ):
+        self.bioyond_config = bioyond_config or {
+            "base_url": "http://192.168.1.200:44386",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+
+
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+        self.order_status = {}
+        try:
+            t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+            t.start()
+        except Exception as e:
+            logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    @property
+    def device_id(self) -> str:
+        try:
+            return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+        except Exception:
+            return "bioyond_workstation"
+
+    def _start_http_service_bg(self, host: str = "127.0.0.1", port: int = 8080) -> None:
+        try:
+            self.service = WorkstationHTTPService(self, host=host, port=port)
+            self.service.start()
+        except Exception as e:
+            logger.error(f"启动HTTP服务失败: {e}")
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+        if data is not None:
+            payload["data"] = data
+
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+
+        response = self._post_lims("/api/lims/order/orders", orders)
+        self.order_status[response["data"]["orderCode"]] = "running"
+
+        while True:
+            time.sleep(5)
+            if self.order_status.get(response["data"]["orderCode"], None) == "finished":
+                break
+        return response
+
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/scheduler/start")
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+
+    # 套接字服务端收到“步骤完成”时调用
+    def process_step_finish_report(self, report_request):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "step_finished"
+            logger.info(f"[REPORT] 订单 {order_code} 步骤完成")
+        return {"ack": True}
+
+    def process_order_finish_report(self, report_request, used_materials=None):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "finished"
+            logger.info(f"[REPORT] 订单 {order_code} 已完成，状态改为 finished")
+        return {"ack": True, "usedMaterials": used_materials or []}
+
+    # 收到“通量完成”时调用
+    def process_sample_finish_report(self, report_request):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "sample_finished"
+            logger.info(f"[REPORT] 订单 {order_code} 通量完成")
+        return {"ack": True}
+
+    def test_benyao_workstation(self, num1, num2):
+        num1 = int(num1)
+        num2 = int(num2)
+        for i in range(num1):
+            print(f"num1 = {num1}")
+        for j in range(num2):
+            print(f"num1 = {num2}")
+        test_benyao_api()
+        
+        
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    # ws.scheduler_stop()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # 新建实验
+    # res = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092501.xlsx")
+    # print(res)
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])
+    
+    # r321 = ws.transfer_3_to_2_to_1()
+    # ws.transfer_1_to_2()
+
+
--- a/unilabos/devices/workstation/bioyond_cell/cellconfig3c.json
+++ b/unilabos/devices/workstation/bioyond_cell/cellconfig3c.json
@@ -0,0 +1,706 @@
+{
+  "nodes": [
+  {
+        "id": "bioyond_workstation",
+        "name": "配液分液工站",
+        "children": [
+        ],
+        "parent": null,
+        "type": "device",
+        "class": "bioyondworkstation_device",
+        "config": {
+            "protocol_type": [],
+            "station_resource": {}
+
+        },
+        "data": {}
+    },
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "children": [
+          "coin_cell_deck"
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "bettery_station_registry",
+      "position": {
+          "x": 600,
+          "y": 400,
+          "z": 0
+      },
+      "config": {
+          "debug_mode": false,
+          "_comment": "protocol_type接外部工站固定写法字段，一般为空，station_resource写法也固定",
+          "protocol_type": [],
+          "station_resource": {
+              "data": {
+                  "_resource_child_name": "coin_cell_deck",
+                  "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.button_battery_station:CoincellDeck"
+              }
+          },
+          
+          "address": "192.168.1.20",
+          "port": 502
+      },
+      "data": {}
+    },
+    {
+      "id": "coin_cell_deck",
+      "name": "coin_cell_deck",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8"
+      ],
+      "parent": null,
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "CoincellDeck",
+        "size_x": 1000,
+        "size_y": 1000,
+        "size_z": 900,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "coin_cell_deck",
+        "barcode": null
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8",
+      "name": "\u7535\u6c60\u6599\u76d8",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+      ],
+      "parent": "coin_cell_deck",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 100,
+        "y": 100,
+        "z": 0
+      },
+      "config": {
+        "type": "MaterialPlate",
+        "size_x": 120.8,
+        "size_y": 160.5,
+        "size_z": 10.0,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {
+          "A1": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+          "B1": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+          "C1": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+          "D1": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+          "A2": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+          "B2": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+          "C2": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+          "D2": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+          "A3": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+          "B3": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+          "C3": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+          "D3": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+          "A4": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+          "B4": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+          "C4": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+          "D4": "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+        }
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    }
+  ],
+  "links": []
+}
--- a/unilabos/devices/workstation/bioyond_cell/cellconfig3ca.json
+++ b/unilabos/devices/workstation/bioyond_cell/cellconfig3ca.json
@@ -0,0 +1,20 @@
+{
+  "nodes": [
+  {
+        "id": "bioyond_workstation",
+        "name": "配液分液工站",
+        "children": [
+        ],
+        "parent": null,
+        "type": "device",
+        "class": "bioyondworkstation_device",
+        "config": {
+            "protocol_type": [],
+            "station_resource": {}
+
+        },
+        "data": {}
+    }
+  ],
+  "links": []
+}
--- a/unilabos/devices/workstation/bioyond_cell/样品导入模板.xlsx
+++ b/unilabos/devices/workstation/bioyond_cell/样品导入模板.xlsx
--- a/unilabos/devices/workstation/bioyond_material_management.py
+++ b/unilabos/devices/workstation/bioyond_material_management.py
@@ -0,0 +1,374 @@
+"""
+Bioyond物料管理实现
+Bioyond Material Management Implementation
+
+基于Bioyond系统的物料管理，支持从Bioyond系统同步物料到UniLab工作站
+"""
+from typing import Dict, Any, List, Optional, Union
+import json
+import asyncio
+from abc import ABC, abstractmethod
+
+from pylabrobot.resources import (
+    Resource as PLRResource,
+    Container,
+    Deck,
+    Coordinate as PLRCoordinate,
+)
+
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
+from unilabos.utils.log import logger
+from unilabos.resources.graphio import (
+    resource_plr_to_ulab, 
+    resource_ulab_to_plr,
+    resource_bioyond_to_ulab,
+    resource_bioyond_container_to_ulab,
+    resource_ulab_to_bioyond
+)
+from .workstation_material_management import MaterialManagementBase
+
+
+class BioyondMaterialManagement(MaterialManagementBase):
+    """Bioyond物料管理类
+    
+    实现从Bioyond系统同步物料到UniLab工作站的功能：
+    1. 从Bioyond系统获取物料数据
+    2. 转换为UniLab格式
+    3. 同步到PyLabRobot Deck
+    4. 支持双向同步
+    """
+    
+    def __init__(
+        self,
+        device_id: str,
+        deck_config: Dict[str, Any],
+        resource_tracker: DeviceNodeResourceTracker,
+        children_config: Dict[str, Dict[str, Any]] = None,
+        bioyond_config: Dict[str, Any] = None
+    ):
+        self.bioyond_config = bioyond_config or {}
+        self.bioyond_api_client = None
+        self.sync_interval = self.bioyond_config.get("sync_interval", 30)  # 同步间隔（秒）
+        
+        # 初始化父类
+        super().__init__(device_id, deck_config, resource_tracker, children_config)
+        
+        # 初始化Bioyond API客户端
+        self._initialize_bioyond_client()
+        
+        # 启动同步任务
+        self._start_sync_task()
+    
+    def _initialize_bioyond_client(self):
+        """初始化Bioyond API客户端"""
+        try:
+            # 这里应该根据实际的Bioyond API实现
+            # 暂时使用模拟客户端
+            self.bioyond_api_client = BioyondAPIClient(self.bioyond_config)
+            logger.info(f"Bioyond API客户端初始化成功")
+        except Exception as e:
+            logger.error(f"Bioyond API客户端初始化失败: {e}")
+            self.bioyond_api_client = None
+    
+    def _start_sync_task(self):
+        """启动同步任务"""
+        if self.bioyond_api_client:
+            # 创建异步同步任务
+            asyncio.create_task(self._periodic_sync())
+            logger.info(f"Bioyond同步任务已启动，间隔: {self.sync_interval}秒")
+    
+    async def _periodic_sync(self):
+        """定期同步任务"""
+        while True:
+            try:
+                await self.sync_from_bioyond()
+                await asyncio.sleep(self.sync_interval)
+            except Exception as e:
+                logger.error(f"Bioyond同步任务出错: {e}")
+                await asyncio.sleep(self.sync_interval)
+    
+    async def sync_from_bioyond(self) -> bool:
+        """从Bioyond系统同步物料"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 从Bioyond获取物料数据
+            bioyond_data = await self.bioyond_api_client.get_materials()
+            if not bioyond_data:
+                logger.warning("从Bioyond获取物料数据为空")
+                return False
+            
+            # 2. 转换为UniLab格式
+            if isinstance(bioyond_data, dict) and "data" in bioyond_data:
+                # 容器格式数据
+                unilab_resources = resource_bioyond_container_to_ulab(bioyond_data)
+            else:
+                # 物料列表格式数据
+                unilab_resources = resource_bioyond_to_ulab(bioyond_data)
+            
+            # 3. 转换为PLR格式并分配到Deck
+            await self._assign_resources_to_deck(unilab_resources)
+            
+            logger.info(f"从Bioyond同步了 {len(unilab_resources)} 个资源")
+            return True
+            
+        except Exception as e:
+            logger.error(f"从Bioyond同步物料失败: {e}")
+            return False
+    
+    async def sync_to_bioyond(self, plr_resource: PLRResource) -> bool:
+        """将本地物料变更同步到Bioyond系统"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 转换为UniLab格式
+            unilab_resource = resource_plr_to_ulab(plr_resource)
+            
+            # 2. 转换为Bioyond格式
+            bioyond_materials = resource_ulab_to_bioyond([unilab_resource])
+            
+            # 3. 发送到Bioyond系统
+            success = await self.bioyond_api_client.update_materials(bioyond_materials)
+            
+            if success:
+                logger.info(f"成功同步物料 {plr_resource.name} 到Bioyond")
+            else:
+                logger.warning(f"同步物料 {plr_resource.name} 到Bioyond失败")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"同步物料到Bioyond失败: {e}")
+            return False
+    
+    async def _assign_resources_to_deck(self, unilab_resources: List[Dict[str, Any]]):
+        """将UniLab资源分配到Deck"""
+        try:
+            # 转换为PLR格式
+            from unilabos.resources.graphio import list_to_nested_dict
+            nested_resources = list_to_nested_dict(unilab_resources)
+            plr_resources = resource_ulab_to_plr(nested_resources)
+            
+            # 分配资源到Deck
+            if hasattr(plr_resources, 'children'):
+                resources_to_assign = plr_resources.children
+            elif isinstance(plr_resources, list):
+                resources_to_assign = plr_resources
+            else:
+                resources_to_assign = [plr_resources]
+            
+            for resource in resources_to_assign:
+                try:
+                    # 获取资源位置
+                    if hasattr(resource, 'location') and resource.location:
+                        location = PLRCoordinate(resource.location.x, resource.location.y, resource.location.z)
+                    else:
+                        location = PLRCoordinate(0, 0, 0)
+                    
+                    # 分配资源到Deck
+                    self.plr_deck.assign_child_resource(resource, location)
+                    
+                    # 注册到resource tracker
+                    self.resource_tracker.add_resource(resource)
+                    
+                    # 保存资源引用
+                    self.plr_resources[resource.name] = resource
+                    
+                except Exception as e:
+                    logger.error(f"分配资源 {resource.name} 到Deck失败: {e}")
+            
+            logger.info(f"成功分配了 {len(resources_to_assign)} 个资源到Deck")
+            
+        except Exception as e:
+            logger.error(f"分配资源到Deck失败: {e}")
+    
+    def _create_resource_by_type(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """根据类型创建Bioyond相关资源"""
+        try:
+            # 这里可以根据需要实现特定的Bioyond资源类型
+            # 目前使用通用的容器类型
+            if resource_type in ["container", "plate", "well"]:
+                return self._create_generic_container(resource_id, resource_type, config, data, location)
+            else:
+                logger.warning(f"未知的Bioyond资源类型: {resource_type}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"创建Bioyond资源失败 {resource_id} ({resource_type}): {e}")
+            return None
+    
+    def _create_generic_container(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """创建通用容器资源"""
+        try:
+            from pylabrobot.resources import Plate, Well
+            
+            if resource_type == "plate":
+                return Plate(
+                    name=resource_id,
+                    size_x=config.get("size_x", 127.76),
+                    size_y=config.get("size_y", 85.48),
+                    size_z=config.get("size_z", 14.35),
+                    location=location,
+                    category="plate"
+                )
+            elif resource_type == "well":
+                return Well(
+                    name=resource_id,
+                    size_x=config.get("size_x", 9.0),
+                    size_y=config.get("size_y", 9.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="well"
+                )
+            else:
+                return Container(
+                    name=resource_id,
+                    size_x=config.get("size_x", 50.0),
+                    size_y=config.get("size_y", 50.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="container"
+                )
+                
+        except Exception as e:
+            logger.error(f"创建通用容器失败 {resource_id}: {e}")
+            return None
+    
+    def get_bioyond_materials(self) -> List[Dict[str, Any]]:
+        """获取当前Bioyond物料列表"""
+        try:
+            # 将当前PLR资源转换为Bioyond格式
+            bioyond_materials = []
+            for resource in self.plr_resources.values():
+                unilab_resource = resource_plr_to_ulab(resource)
+                bioyond_materials.extend(resource_ulab_to_bioyond([unilab_resource]))
+            return bioyond_materials
+        except Exception as e:
+            logger.error(f"获取Bioyond物料列表失败: {e}")
+            return []
+    
+    def update_material_from_bioyond(self, material_id: str, bioyond_data: Dict[str, Any]) -> bool:
+        """从Bioyond数据更新指定物料"""
+        try:
+            # 查找现有物料
+            material = self.find_material_by_id(material_id)
+            if not material:
+                logger.warning(f"未找到物料: {material_id}")
+                return False
+            
+            # 转换Bioyond数据为UniLab格式
+            unilab_resources = resource_bioyond_to_ulab([bioyond_data])
+            if not unilab_resources:
+                logger.warning(f"转换Bioyond数据失败: {material_id}")
+                return False
+            
+            # 更新物料属性
+            unilab_resource = unilab_resources[0]
+            material.name = unilab_resource.get("name", material.name)
+            
+            # 更新位置
+            position = unilab_resource.get("position", {})
+            if position:
+                material.location = PLRCoordinate(
+                    position.get("x", 0),
+                    position.get("y", 0),
+                    position.get("z", 0)
+                )
+            
+            logger.info(f"成功更新物料: {material_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新物料失败 {material_id}: {e}")
+            return False
+
+
+class BioyondAPIClient:
+    """Bioyond API客户端（模拟实现）
+    
+    实际使用时需要根据Bioyond系统的API接口实现
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get("base_url", "http://localhost:8080")
+        self.api_key = config.get("api_key", "")
+        self.timeout = config.get("timeout", 30)
+    
+    async def get_materials(self) -> Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]:
+        """从Bioyond系统获取物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            # 暂时返回模拟数据
+            logger.info("从Bioyond API获取物料数据")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据（实际应该从API获取）
+            return {
+                "data": [],
+                "code": 1,
+                "message": "success",
+                "timestamp": 1234567890
+            }
+            
+        except Exception as e:
+            logger.error(f"Bioyond API调用失败: {e}")
+            return None
+    
+    async def update_materials(self, materials: List[Dict[str, Any]]) -> bool:
+        """更新Bioyond系统中的物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"更新Bioyond系统中的 {len(materials)} 个物料")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 模拟成功响应
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新Bioyond物料失败: {e}")
+            return False
+    
+    async def get_material_by_id(self, material_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取单个物料"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"从Bioyond API获取物料: {material_id}")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据
+            return {
+                "id": material_id,
+                "name": f"material_{material_id}",
+                "type": "container",
+                "quantity": 1.0,
+                "unit": "个"
+            }
+            
+        except Exception as e:
+            logger.error(f"获取Bioyond物料失败 {material_id}: {e}")
+            return None
--- a/unilabos/devices/workstation/bioyond_studio/config.py
+++ b/unilabos/devices/workstation/bioyond_studio/config.py
@@ -1,129 +0,0 @@
-# config.py
-"""
-配置文件 - 包含所有配置信息和映射关系
-"""
-
-# API配置
-API_CONFIG = {
-    "api_key": "",
-    "api_host": ""
-}
-
-# 站点类型配置
-STATION_TYPES = {
-    "REACTION": "reaction_station",      # 仅反应站
-    "DISPENSING": "dispensing_station",  # 仅配液站
-    "HYBRID": "hybrid_station"           # 混合模式
-}
-
-# 默认站点配置
-DEFAULT_STATION_CONFIG = {
-    "station_type": STATION_TYPES["REACTION"],  # 默认反应站模式
-    "enable_reaction_station": True,            # 是否启用反应站功能
-    "enable_dispensing_station": False,         # 是否启用配液站功能
-    "station_name": "BioyondReactionStation",   # 站点名称
-    "description": "Bioyond反应工作站"          # 站点描述
-}
-
-# 工作流映射配置
-WORKFLOW_MAPPINGS = {
-    "reactor_taken_out": "",
-    "reactor_taken_in": "",
-    "Solid_feeding_vials": "",
-    "Liquid_feeding_vials(non-titration)": "",
-    "Liquid_feeding_solvents": "",
-    "Liquid_feeding(titration)": "",
-    "liquid_feeding_beaker": "",
-    "Drip_back": "",
-}
-
-# 工作流名称到DisplaySectionName的映射
-WORKFLOW_TO_SECTION_MAP = {
-    'reactor_taken_in': '反应器放入',
-    'liquid_feeding_beaker': '液体投料-烧杯',
-    'Liquid_feeding_vials(non-titration)': '液体投料-小瓶（非滴定）',
-    'Liquid_feeding_solvents': '液体投料-溶剂',
-    'Solid_feeding_vials': '固体投料-小瓶',
-    'Liquid_feeding(titration)': '液体投料-滴定',
-    'reactor_taken_out': '反应器取出'
-}
-
-# 库位映射配置
-LOCATION_MAPPING = {
-    'A01': '',
-    'A02': '',
-    'A03': '',
-    'A04': '',
-    'A05': '',
-    'A06': '',
-    'A07': '',
-    'A08': '',
-    'B01': '',
-    'B02': '',
-    'B03': '',
-    'B04': '',
-    'B05': '',
-    'B06': '',
-    'B07': '',
-    'B08': '',
-    'C01': '',
-    'C02': '',
-    'C03': '',
-    'C04': '',
-    'C05': '',
-    'C06': '',
-    'C07': '',
-    'C08': '',
-    'D01': '',
-    'D02': '',
-    'D03': '',
-    'D04': '',
-    'D05': '',
-    'D06': '',
-    'D07': '',
-    'D08': '',
-}
-
-# 物料类型配置
-MATERIAL_TYPE_IDS = {
-    "样品板": "",
-    "样品": "",
-    "烧杯": ""
-}
-
-MATERIAL_TYPE_MAPPINGS = {
-    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-    "样品板": "BIOYOND_PolymerStation_6VialCarrier",
-}
-
-# 步骤参数配置（各工作流的步骤UUID）
-WORKFLOW_STEP_IDS = {
-    "reactor_taken_in": {
-        "config": ""
-    },
-    "liquid_feeding_beaker": {
-        "liquid": "",
-        "observe": ""
-    },
-    "liquid_feeding_vials_non_titration": {
-        "liquid": "",
-        "observe": ""
-    },
-    "liquid_feeding_solvents": {
-        "liquid": "",
-        "observe": ""
-    },
-    "solid_feeding_vials": {
-        "feeding": "",
-        "observe": ""
-    },
-    "liquid_feeding_titration": {
-        "liquid": "",
-        "observe": ""
-    },
-    "drip_back": {
-        "liquid": "",
-        "observe": ""
-    }
-}
--- a/unilabos/devices/workstation/bioyond_studio/station.py
+++ b/unilabos/devices/workstation/bioyond_studio/station.py
@@ -10,14 +10,12 @@ import json

 from unilabos.devices.workstation.workstation_base import WorkstationBase, ResourceSynchronizer
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondV1RPC
-from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
 from unilabos.resources.warehouse import WareHouse
 from unilabos.utils.log import logger
 from unilabos.resources.graphio import resource_bioyond_to_plr

 from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode
 from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
-from pylabrobot.resources.resource import Resource as ResourcePLR

 from unilabos.devices.workstation.bioyond_studio.config import (
    API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS,
@@ -155,14 +153,6 @@ class BioyondWorkstation(WorkstationBase):
            "resources": [self.deck]
        })

-    def transfer_resource_to_another(self, resource: List[ResourceSlot], mount_resource: List[ResourceSlot], sites: List[str], mount_device_id: DeviceSlot):
-        ROS2DeviceNode.run_async_func(self._ros_node.transfer_resource_to_another, True, **{
-            "plr_resources": resource,
-            "target_device_id": mount_device_id,
-            "target_resources": mount_resource,
-            "sites": sites,
-        })
-
    def _configure_station_type(self, station_config: Optional[Dict[str, Any]] = None) -> None:
        """配置站点类型和功能模块

--- a/unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py
+++ b/unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py
@@ -24,6 +24,13 @@ class ElectrodeSheetState(TypedDict):
    thickness: float  # 厚度 (mm)
    mass: float  # 质量 (g)
    material_type: str  # 材料类型（正极、负极、隔膜、弹片、垫片、铝箔等）
+    height: float
+    electrolyte_name: str
+    data_electrolyte_code: str
+    open_circuit_voltage: float
+    assembly_pressure: float
+    electrolyte_volume: float
+
    info: Optional[str]  # 附加信息

 class ElectrodeSheet(Resource):
@@ -61,6 +68,7 @@ class ElectrodeSheet(Resource):
            info=None
        )

+    # TODO: 这个还要不要？给self._unilabos_state赋值的？
    def load_state(self, state: Dict[str, Any]) -> None:
        """格式不变"""
        super().load_state(state)
@@ -146,10 +154,10 @@ class MaterialHole(Resource):
    ):
        """放置极片"""
        # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题
-        if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]:
-            raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}")
-        if len(self.children) >= self._unilabos_state["max_sheets"]:
-            raise ValueError(f"洞位已满，无法放置更多极片")
+        #if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]:
+        #    raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}")
+        #if len(self.children) >= self._unilabos_state["max_sheets"]:
+        #    raise ValueError(f"洞位已满，无法放置更多极片")
        super().assign_child_resource(resource, location, reassign)

    # 根据children的编号取物料对象。
@@ -164,8 +172,6 @@ class MaterialPlateState(TypedDict):
    hole_diameter: float
    info: Optional[str]  # 附加信息

-
-
 class MaterialPlate(ItemizedResource[MaterialHole]):
    """料板类 - 4x4个洞位，每个洞位放1个极片"""
    
@@ -323,12 +329,13 @@ class PlateSlot(ResourceStack):

 class ClipMagazineHole(Container):
    """子弹夹洞位类"""
-    children: List[ElectrodeSheet] = []
+
    def __init__(
        self,
        name: str,
        diameter: float,
        depth: float,
+        max_sheets: int = 100,
        category: str = "clip_magazine_hole",
    ):
        """初始化子弹夹洞位
@@ -337,6 +344,7 @@ class ClipMagazineHole(Container):
            name: 洞位名称
            diameter: 洞直径 (mm)
            depth: 洞深度 (mm)
+            max_sheets: 最大极片数量
            category: 类别
        """
        super().__init__(
@@ -348,143 +356,46 @@ class ClipMagazineHole(Container):
        )
        self.diameter = diameter
        self.depth = depth
+        self.max_sheets = max_sheets
+        self._sheets: List[ElectrodeSheet] = []

    def can_add_sheet(self, sheet: ElectrodeSheet) -> bool:
-        """检查是否可以添加极片
-        
-        根据洞的深度和极片的厚度来判断是否可以添加极片
-        """
-        # 检查极片直径是否适合洞的直径
-        if sheet._unilabos_state["diameter"] > self.diameter:
-            return False
-        
-        # 计算当前已添加极片的总厚度
-        current_thickness = sum(s._unilabos_state["thickness"] for s in self.children)
-        
-        # 检查添加新极片后总厚度是否超过洞的深度
-        if current_thickness + sheet._unilabos_state["thickness"] > self.depth:
-            return False
-        
-        return True
+        """检查是否可以添加极片"""
+        return (len(self._sheets) < self.max_sheets and
+                sheet.diameter <= self.diameter)

+    def add_sheet(self, sheet: ElectrodeSheet) -> None:
+        """添加极片"""
+        if not self.can_add_sheet(sheet):
+            raise ValueError(f"无法向洞位 {self.name} 添加极片")
+        self._sheets.append(sheet)

-    def assign_child_resource(
-        self,
-        resource: ElectrodeSheet,
-        location: Optional[Coordinate] = None,
-        reassign: bool = True,
-    ):
-        """放置极片到洞位中
-        
-        Args:
-            resource: 要放置的极片
-            location: 极片在洞位中的位置（对于洞位，通常为None）
-            reassign: 是否允许重新分配
-        """
-        # 检查是否可以添加极片
-        if not self.can_add_sheet(resource):
-            raise ValueError(f"无法向洞位 {self.name} 添加极片：直径或厚度不匹配")
-        
-        # 调用父类方法实际执行分配
-        super().assign_child_resource(resource, location, reassign)
-
-    def unassign_child_resource(self, resource: ElectrodeSheet):
-        """从洞位中移除极片
-        
-        Args:
-            resource: 要移除的极片
-        """
-        if resource not in self.children:
-            raise ValueError(f"极片 {resource.name} 不在洞位 {self.name} 中")
-        
-        # 调用父类方法实际执行移除
-        super().unassign_child_resource(resource)
-
+    def take_sheet(self) -> ElectrodeSheet:
+        """取出极片"""
+        if len(self._sheets) == 0:
+            raise ValueError(f"洞位 {self.name} 没有极片")
+        return self._sheets.pop()

+    def get_sheet_count(self) -> int:
+        """获取极片数量"""
+        return len(self._sheets)

    def serialize_state(self) -> Dict[str, Any]:
        return {
-            "sheet_count": len(self.children),
-            "sheets": [sheet.serialize() for sheet in self.children],
+            "sheet_count": len(self._sheets),
+            "sheets": [sheet.serialize() for sheet in self._sheets],
        }
-class ClipMagazine_four(ItemizedResource[ClipMagazineHole]):
-    """子弹夹类 - 有4个洞位，每个洞位放多个极片"""
-    children: List[ClipMagazineHole]
-    def __init__(
-        self,
-        name: str,
-        size_x: float,
-        size_y: float,
-        size_z: float,
-        hole_diameter: float = 14.0,
-        hole_depth: float = 10.0,
-        hole_spacing: float = 25.0,
-        max_sheets_per_hole: int = 100,
-        category: str = "clip_magazine_four",
-        model: Optional[str] = None,
-    ):
-        """初始化子弹夹

-        Args:
-            name: 子弹夹名称
-            size_x: 长度 (mm)
-            size_y: 宽度 (mm)
-            size_z: 高度 (mm)
-            hole_diameter: 洞直径 (mm)
-            hole_depth: 洞深度 (mm)
-            hole_spacing: 洞位间距 (mm)
-            max_sheets_per_hole: 每个洞位最大极片数量
-            category: 类别
-            model: 型号
-        """
-        # 创建4个洞位，排成2x2布局
-        holes = create_ordered_items_2d(
-            klass=ClipMagazineHole,
-            num_items_x=2,
-            num_items_y=2,
-            dx=(size_x - 2 * hole_spacing) / 2,  # 居中
-            dy=(size_y - hole_spacing) / 2,     # 居中
-            dz=size_z - 0,
-            item_dx=hole_spacing,
-            item_dy=hole_spacing,
-            diameter=hole_diameter,
-            depth=hole_depth,
-        )
-
-        super().__init__(
-            name=name,
-            size_x=size_x,
-            size_y=size_y,
-            size_z=size_z,
-            ordered_items=holes,
-            category=category,
-            model=model,
-        )
-
-        # 保存洞位的直径和深度
-        self.hole_diameter = hole_diameter
-        self.hole_depth = hole_depth
-        self.max_sheets_per_hole = max_sheets_per_hole
-
-    def serialize(self) -> dict:
-        return {
-            **super().serialize(),
-            "hole_diameter": self.hole_diameter,
-            "hole_depth": self.hole_depth,
-            "max_sheets_per_hole": self.max_sheets_per_hole,
-        }
 # TODO: 这个要改
-class ClipMagazine(ItemizedResource[ClipMagazineHole]):
+class ClipMagazine(Resource):
    """子弹夹类 - 有6个洞位，每个洞位放多个极片"""
-    children: List[ClipMagazineHole]
+
    def __init__(
        self,
        name: str,
        size_x: float,
        size_y: float,
        size_z: float,
-        hole_diameter: float = 14.0,
-        hole_depth: float = 10.0,
        hole_spacing: float = 25.0,
        max_sheets_per_hole: int = 100,
        category: str = "clip_magazine",
@@ -514,8 +425,8 @@ class ClipMagazine(ItemizedResource[ClipMagazineHole]):
            dz=size_z - 0,
            item_dx=hole_spacing,
            item_dy=hole_spacing,
-            diameter=hole_diameter,
-            depth=hole_depth,
+            diameter=0,
+            depth=0,
        )

        super().__init__(
@@ -528,7 +439,6 @@ class ClipMagazine(ItemizedResource[ClipMagazineHole]):
            model=model,
        )

-        # 保存洞位的直径和深度
        self.hole_diameter = hole_diameter
        self.hole_depth = hole_depth
        self.max_sheets_per_hole = max_sheets_per_hole
@@ -545,9 +455,9 @@ class BatteryState(TypedDict):
    """电池状态字典"""
    diameter: float
    height: float
-
-    electrolyte_name: str
+    assembly_pressure: float
    electrolyte_volume: float
+    electrolyte_name: str

 class Battery(Resource):
    """电池类 - 可容纳极片"""
@@ -556,6 +466,9 @@ class Battery(Resource):
    def __init__(
        self,
        name: str,
+        size_x=1,
+        size_y=1,
+        size_z=1,
        category: str = "battery",
    ):
        """初始化电池
@@ -576,7 +489,13 @@ class Battery(Resource):
            size_z=1,
            category=category,
        )
-        self._unilabos_state: BatteryState = BatteryState()
+        self._unilabos_state: BatteryState = BatteryState(
+                                 diameter = 1.0,
+                                 height = 1.0,
+                                 assembly_pressure = 1.0,
+                                 electrolyte_volume = 1.0,
+                                 electrolyte_name = "DP001"
+                                 )

    def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool:
        to_add_name = bottle._unilabos_state["electrolyte_name"]
@@ -664,6 +583,7 @@ class BatteryPressSlot(Resource):
        reassign: bool = True,
    ):
        """放置极片"""
+        # TODO: 让高京看下槽位只有一个电池时是否这么写。
        if self.has_battery():
            raise ValueError(f"槽位已含有一个电池，无法再放置其他电池")
        super().assign_child_resource(resource, location, reassign)
@@ -672,6 +592,7 @@ class BatteryPressSlot(Resource):
    def get_battery_info(self, index: int) -> Battery:
        return self.children[0]

+# TODO:这个移液枪架子看一下从哪继承
 class TipBox64State(TypedDict):
    """电池状态字典"""
    tip_diameter: float = 5.0
@@ -730,15 +651,6 @@ class TipBox64(TipRack):
            make_tip=make_tip,
        )
        self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate()
-        # 记录网格参数用于前端渲染
-        self._grid_params = {
-            "num_items_x": 8,
-            "num_items_y": 8,
-            "dx": 8.0,
-            "dy": 8.0,
-            "item_dx": 9.0,
-            "item_dy": 9.0,
-        }
        super().__init__(
            name=name,
            size_x=size_x,
@@ -750,12 +662,6 @@ class TipBox64(TipRack):
            with_tips=True,
        )

-    def serialize(self) -> dict:
-        return {
-            **super().serialize(),
-            **self._grid_params,
-        }
-


 class WasteTipBoxstate(TypedDict):
@@ -833,34 +739,19 @@ class BottleRackState(TypedDict):
    name_to_index: dict


-class BottleRackState(TypedDict):
-    """     bottle_diameter: 瓶子直径 (mm)
-            bottle_height: 瓶子高度 (mm)
-            position_spacing: 位置间距 (mm)"""
-    bottle_diameter: float
-    bottle_height: float
-    position_spacing: float
-    name_to_index: dict
-

 class BottleRack(Resource):
    """瓶架类 - 12个待配位置+12个已配位置"""
-    children: List[Resource] = []
+    children: List[Bottle] = []

    def __init__(
-            self,
-            name: str,
-            size_x: float,
-            size_y: float,
-            size_z: float,
-            category: str = "bottle_rack",
-            model: Optional[str] = None,
-            num_items_x: int = 3,
-            num_items_y: int = 4,
-            position_spacing: float = 35.0,
-            orientation: str = "horizontal",
-            padding_x: float = 20.0,
-            padding_y: float = 20.0,
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        category: str = "bottle_rack",
+        model: Optional[str] = None,
    ):
        """初始化瓶架

@@ -880,42 +771,13 @@ class BottleRack(Resource):
            category=category,
            model=model,
        )
-        # 初始化状态
-        self._unilabos_state: BottleRackState = BottleRackState(
-            bottle_diameter=30.0,
-            bottle_height=100.0,
-            position_spacing=position_spacing,
-            name_to_index={},
-        )
-        # 基于网格生成瓶位坐标映射（居中摆放）
-        # 使用内边距，避免点跑到容器外（前端渲染不按mm等比缩放时更稳妥）
-        origin_x = padding_x
-        origin_y = padding_y
-        self.index_to_pos = {}
-        for j in range(num_items_y):
-            for i in range(num_items_x):
-                idx = j * num_items_x + i
-                if orientation == "vertical":
-                    # 纵向：沿 y 方向优先排列
-                    self.index_to_pos[idx] = Coordinate(
-                        x=origin_x + j * position_spacing,
-                        y=origin_y + i * position_spacing,
-                        z=0,
-                    )
-                else:
-                    # 横向（默认）：沿 x 方向优先排列
-                    self.index_to_pos[idx] = Coordinate(
-                        x=origin_x + i * position_spacing,
-                        y=origin_y + j * position_spacing,
-                        z=0,
-                    )
+        # TODO: 添加瓶位坐标映射
+        self.index_to_pos = {
+            0: Coordinate.zero(),
+            1: Coordinate(x=1, y=2, z=3)  # 添加
+        }
        self.name_to_index = {}
        self.name_to_pos = {}
-        self.num_items_x = num_items_x
-        self.num_items_y = num_items_y
-        self.orientation = orientation
-        self.padding_x = padding_x
-        self.padding_y = padding_y

    def load_state(self, state: Dict[str, Any]) -> None:
        """格式不变"""
@@ -925,23 +787,20 @@ class BottleRack(Resource):
    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
        """格式不变"""
        data = super().serialize_state()
-        data.update(
-            self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
        return data

    # TODO: 这里有些问题要重新写一下
-    def assign_child_resource_old(self, resource: Resource, location=Coordinate.zero(), reassign=True):
-        capacity = self.num_items_x * self.num_items_y
-        assert len(self.children) < capacity, "瓶架已满，无法添加更多瓶子"
+    def assign_child_resource(self, resource: Bottle, location=Coordinate.zero(), reassign = True):
+        assert len(self.children) <= 12, "瓶架已满，无法添加更多瓶子"
        index = len(self.children)
-        location = self.index_to_pos.get(index, Coordinate.zero())
+        location = Coordinate(x=20 + (index % 4) * 15, y=20 + (index // 4) * 15, z=0)
        self.name_to_pos[resource.name] = location
        self.name_to_index[resource.name] = index
        return super().assign_child_resource(resource, location, reassign)
-
-    def assign_child_resource(self, resource: Resource, index: int):
-        capacity = self.num_items_x * self.num_items_y
-        assert 0 <= index < capacity, "无效的瓶子索引"
+    
+    def assign_child_resource_by_index(self, resource: Bottle, index: int):
+        assert 0 <= index < 12, "无效的瓶子索引"
        self.name_to_index[resource.name] = index
        location = self.index_to_pos[index]
        return super().assign_child_resource(resource, location)
@@ -950,16 +809,9 @@ class BottleRack(Resource):
        super().unassign_child_resource(resource)
        self.index_to_pos.pop(self.name_to_index.pop(resource.name, None), None)

-    def serialize(self) -> dict:
-        return {
-            **super().serialize(),
-            "num_items_x": self.num_items_x,
-            "num_items_y": self.num_items_y,
-            "position_spacing": self._unilabos_state.get("position_spacing", 35.0),
-            "orientation": self.orientation,
-            "padding_x": self.padding_x,
-            "padding_y": self.padding_y,
-        }
+    # def serialize(self):
+    #     self.children.sort(key=lambda x: self.name_to_index.get(x.name, 0))
+    #     return super().serialize()


 class BottleState(TypedDict):
@@ -1095,16 +947,20 @@ class CoincellDeck(Deck):
 #            plate.assign_child_resource(hole)
 #    return plate

-def create_a_liaopan():
-    liaopan = MaterialPlate(name="liaopan", size_x=120.8, size_y=120.5, size_z=10.0, fill=True)
-    for i in range(16):
-        jipian = ElectrodeSheet(name=f"jipian_{i}", size_x= 12, size_y=12, size_z=0.1)
-        liaopan1.children[i].assign_child_resource(jipian, location=None)
-    return liaopan
+import json

-def create_a_coin_cell_deck():
-    deck = Deck(size_x=1200,
-                size_y=800,
+if __name__ == "__main__":
+    #electrode1 = BatteryPressSlot()
+    #print(electrode1.get_size_x())
+    #print(electrode1.get_size_y())
+    #print(electrode1.get_size_z())
+    #jipian = ElectrodeSheet()
+    #jipian._unilabos_state["diameter"] = 18
+    #print(jipian.serialize())
+    #print(jipian.serialize_state())
+
+    deck = CoincellDeck(size_x=1000,
+                size_y=1000,
                size_z=900)

    #liaopan =  TipBox64(name="liaopan")
@@ -1115,172 +971,33 @@ def create_a_coin_cell_deck():
    deck.assign_child_resource(liaopan1, Coordinate(x=0, y=0, z=0))
    #创建一个极片
    for i in range(16):
-        jipian = ElectrodeSheet(name=f"jipian_{i}", size_x= 12, size_y=12, size_z=0.1)
+        jipian = ElectrodeSheet(name=f"jipian1_{i}", size_x= 12, size_y=12, size_z=0.1)
        liaopan1.children[i].assign_child_resource(jipian, location=None)
+#
    #创建一个4*4的物料板
    liaopan2 =  MaterialPlate(name="liaopan2", size_x=120.8, size_y=120.5, size_z=10.0, fill=True)
    #把物料板放到桌子上
    deck.assign_child_resource(liaopan2, Coordinate(x=500, y=0, z=0))

    #创建一个4*4的物料板
-    liaopan3 =  MaterialPlate(name="liaopan3", size_x=120.8, size_y=120.5, size_z=10.0, fill=True)
+    liaopan3 =  MaterialPlate(name="电池料盘", size_x=120.8, size_y=160.5, size_z=10.0, fill=True)
    #把物料板放到桌子上
-    deck.assign_child_resource(liaopan3, Coordinate(x=1000, y=0, z=0))
-
-    print(deck)
-
-    return deck
+    deck.assign_child_resource(liaopan3, Coordinate(x=100, y=100, z=0))


-import json

-if __name__ == "__main__":
-    electrode1 = BatteryPressSlot()
-    #print(electrode1.get_size_x())
-    #print(electrode1.get_size_y())
-    #print(electrode1.get_size_z())
-    #jipian = ElectrodeSheet()
-    #jipian._unilabos_state["diameter"] = 18
-    #print(jipian.serialize())
-    #print(jipian.serialize_state())
-
-    deck = CoincellDeck()
-    """======================================子弹夹============================================"""
-    zip_dan_jia = ClipMagazine_four("zi_dan_jia", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia, Coordinate(x=1400, y=50, z=0))
-    zip_dan_jia2 = ClipMagazine_four("zi_dan_jia2", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia2, Coordinate(x=1600, y=200, z=0))
-    zip_dan_jia3 = ClipMagazine("zi_dan_jia3", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia3, Coordinate(x=1500, y=200, z=0))
-    zip_dan_jia4 = ClipMagazine("zi_dan_jia4", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia4, Coordinate(x=1500, y=300, z=0))
-    zip_dan_jia5 = ClipMagazine("zi_dan_jia5", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia5, Coordinate(x=1600, y=300, z=0))
-    zip_dan_jia6 = ClipMagazine("zi_dan_jia6", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia6, Coordinate(x=1530, y=500, z=0))
-    zip_dan_jia7 = ClipMagazine("zi_dan_jia7", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia7, Coordinate(x=1180, y=400, z=0))
-    zip_dan_jia8 = ClipMagazine("zi_dan_jia8", 80, 80, 10)
-    deck.assign_child_resource(zip_dan_jia8, Coordinate(x=1280, y=400, z=0))
-    for i in range(4):
-        jipian = ElectrodeSheet(name=f"zi_dan_jia_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia2.children[i].assign_child_resource(jipian, location=None)
-    for i in range(4):
-        jipian2 = ElectrodeSheet(name=f"zi_dan_jia2_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia.children[i].assign_child_resource(jipian2, location=None)
-    for i in range(6):
-        jipian3 = ElectrodeSheet(name=f"zi_dan_jia3_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia3.children[i].assign_child_resource(jipian3, location=None)
-    for i in range(6):
-        jipian4 = ElectrodeSheet(name=f"zi_dan_jia4_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia4.children[i].assign_child_resource(jipian4, location=None)
-    for i in range(6):
-        jipian5 = ElectrodeSheet(name=f"zi_dan_jia5_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia5.children[i].assign_child_resource(jipian5, location=None)
-    for i in range(6):
-        jipian6 = ElectrodeSheet(name=f"zi_dan_jia6_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia6.children[i].assign_child_resource(jipian6, location=None)
-    for i in range(6):
-        jipian7 = ElectrodeSheet(name=f"zi_dan_jia7_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia7.children[i].assign_child_resource(jipian7, location=None)
-    for i in range(6):
-        jipian8 = ElectrodeSheet(name=f"zi_dan_jia8_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        zip_dan_jia8.children[i].assign_child_resource(jipian8, location=None)
-    """======================================子弹夹============================================"""
-    #liaopan =  TipBox64(name="liaopan")
-    """======================================物料板============================================"""
-    #创建一个4*4的物料板
-    liaopan1 = MaterialPlate(name="liaopan1", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan1, Coordinate(x=1010, y=50, z=0))
-    for i in range(16):
-        jipian_1 = ElectrodeSheet(name=f"{liaopan1.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        liaopan1.children[i].assign_child_resource(jipian_1, location=None)
-
-    liaopan2 = MaterialPlate(name="liaopan2", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan2, Coordinate(x=1130, y=50, z=0))
-
-    liaopan3 = MaterialPlate(name="liaopan3", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan3, Coordinate(x=1250, y=50, z=0))
-
-    liaopan4 = MaterialPlate(name="liaopan4", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan4, Coordinate(x=1010, y=150, z=0))
-    for i in range(16):
-        jipian_4 = ElectrodeSheet(name=f"{liaopan4.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        liaopan4.children[i].assign_child_resource(jipian_4, location=None)
-    liaopan5 = MaterialPlate(name="liaopan5", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan5, Coordinate(x=1130, y=150, z=0))
-    liaopan6 = MaterialPlate(name="liaopan6", size_x=120, size_y=100, size_z=10.0, fill=True)
-    deck.assign_child_resource(liaopan6, Coordinate(x=1250, y=150, z=0))
    #liaopan.children[3].assign_child_resource(jipian, location=None)
-    """======================================物料板============================================"""
-    """======================================瓶架，移液枪============================================"""
-    # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒
-    bottle_rack_3x4 = BottleRack(
-        name="bottle_rack_3x4",
-        size_x=210.0,
-        size_y=140.0,
-        size_z=100.0,
-        num_items_x=3,
-        num_items_y=4,
-        position_spacing=35.0,
-        orientation="vertical",
-    )
-    deck.assign_child_resource(bottle_rack_3x4, Coordinate(x=100, y=200, z=0))
-
-    bottle_rack_6x2 = BottleRack(
-        name="bottle_rack_6x2",
-        size_x=120.0,
-        size_y=250.0,
-        size_z=100.0,
-        num_items_x=6,
-        num_items_y=2,
-        position_spacing=35.0,
-        orientation="vertical",
-    )
-    deck.assign_child_resource(bottle_rack_6x2, Coordinate(x=300, y=300, z=0))
-
-    bottle_rack_6x2_2 = BottleRack(
-        name="bottle_rack_6x2_2",
-        size_x=120.0,
-        size_y=250.0,
-        size_z=100.0,
-        num_items_x=6,
-        num_items_y=2,
-        position_spacing=35.0,
-        orientation="vertical",
-    )
-    deck.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=430, y=300, z=0))
-
-
-    # 将 ElectrodeSheet 放满 3x4 与 6x2 的所有孔位
-    for idx in range(bottle_rack_3x4.num_items_x * bottle_rack_3x4.num_items_y):
-        sheet = ElectrodeSheet(name=f"sheet_3x4_{idx}", size_x=12, size_y=12, size_z=0.1)
-        bottle_rack_3x4.assign_child_resource(sheet, index=idx)
-
-    for idx in range(bottle_rack_6x2.num_items_x * bottle_rack_6x2.num_items_y):
-        sheet = ElectrodeSheet(name=f"sheet_6x2_{idx}", size_x=12, size_y=12, size_z=0.1)
-        bottle_rack_6x2.assign_child_resource(sheet, index=idx)
-
-    tip_box = TipBox64(name="tip_box_64")
-    deck.assign_child_resource(tip_box, Coordinate(x=300, y=100, z=0))
-
-    waste_tip_box = WasteTipBox(name="waste_tip_box")
-    deck.assign_child_resource(waste_tip_box, Coordinate(x=300, y=200, z=0))
-    """======================================瓶架，移液枪============================================"""
    print(deck)


    from unilabos.resources.graphio import convert_resources_from_type
    from unilabos.config.config import BasicConfig 
-    BasicConfig.ak = "56bbed5b-6e30-438c-b06d-f69eaa63bb45"
-    BasicConfig.sk = "238222fe-0bf7-4350-a426-e5ced8011dcf"
+    BasicConfig.ak = "4d5ce6ae-7234-4639-834e-93899b9caf94"
+    BasicConfig.sk = "505d3b0a-620e-459a-9905-1efcffce382a"
    from unilabos.app.web.client import http_client

    resources = convert_resources_from_type([deck], [Resource])
-    
-    # 检查序列化后的资源
-
-    json.dump({"nodes": resources, "links": []}, open("button_battery_decks_unilab.json", "w"), indent=2)
+    json.dump({"nodes": resources, "links": []}, open("button_battery_station_resources_unilab.json", "w"), indent=2)
   
      
    #print(resources)
--- a/unilabos/devices/workstation/coin_cell_assembly/button_battery_station_big.py
+++ b/unilabos/devices/workstation/coin_cell_assembly/button_battery_station_big.py
--- a/unilabos/devices/workstation/coin_cell_assembly/button_battery_station_resources_unilab_big.json
+++ b/unilabos/devices/workstation/coin_cell_assembly/button_battery_station_resources_unilab_big.json
--- a/unilabos/devices/workstation/coin_cell_assembly/celljson.json
+++ b/unilabos/devices/workstation/coin_cell_assembly/celljson.json
--- a/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py
+++ b/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py
@@ -21,7 +21,7 @@ from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
 class CoinCellAssemblyWorkstation(WorkstationBase):
    def __init__(
        self,
-        deck: CoincellDeck,
+        station_resource: CoincellDeck,
        address: str = "192.168.1.20",
        port: str = "502",
        debug_mode: bool = True,
@@ -30,12 +30,12 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
    ):
        super().__init__(
            #桌子
-            deck=deck,
+            station_resource=station_resource,
            *args,
            **kwargs,
        )
        self.debug_mode = debug_mode
-        self.deck = deck
+        self.station_resource = station_resource
        """ 连接初始化 """
        modbus_client = TCPClient(addr=address, port=port)
        print("modbus_client", modbus_client)
@@ -60,6 +60,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
        self.csv_export_thread = None
        self.csv_export_running = False
        self.csv_export_file = None
+        self.coin_num_N = 0  #已组装电池数量
        #创建一个物料台面，包含两个极片板
        #self.deck = create_a_coin_cell_deck()
        
@@ -74,7 +75,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
        self._ros_node = ros_node
        #self.deck = create_a_coin_cell_deck()
        ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
-            "resources": [self.deck]
+            "resources": [self.station_resource]
        })

    # 批量操作在这里写
@@ -84,7 +85,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):

    
    async def fill_plate(self):
-        plate_1: MaterialPlate = self.deck.children[0].children[0]
+        plate_1: MaterialPlate = self.station_resource.children[0].children[0]
        #plate_1
        return await self._ros_node.update_resource(plate_1)

@@ -341,7 +342,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
    def modify_deck_name(self, resource_name: str):
        # figure_res = self._ros_node.resource_tracker.figure_resource({"name": resource_name})
        # print(f"!!! figure_res: {type(figure_res)}")
-        self.deck.children[1]
+        self.station_resource.children[1]
        return

    @property
@@ -606,7 +607,8 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
            print("waiting for start_cmd")
            time.sleep(1)      

-    def func_pack_send_bottle_num(self, bottle_num: int):
+    def func_pack_send_bottle_num(self, bottle_num):
+        bottle_num = int(bottle_num)
        #发送电解液平台数
        print("启动")
        while (self._unilab_rece_electrolyte_bottle_num()) == False:
@@ -654,16 +656,25 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
    #    self.success = True
    #    return self.success

-    def func_pack_send_msg_cmd(self, elec_use_num) -> bool:
+    def func_pack_send_msg_cmd(self, elec_use_num, elec_vol, assembly_type, assembly_pressure) -> bool:
        """UNILAB写参数"""    
        while (self.request_rec_msg_status) == False: 
            print("wait for request_rec_msg_status to True")
            time.sleep(1)
        self.success = False
        #self._unilab_send_msg_electrolyte_num(elec_num)
-        time.sleep(1)
+        #设置平行样数目
        self._unilab_send_msg_electrolyte_use_num(elec_use_num)
        time.sleep(1)
+        #发送电解液加注量
+        self._unilab_send_msg_electrolyte_vol(elec_vol)
+        time.sleep(1)
+        #发送电解液组装类型
+        self._unilab_send_msg_assembly_type(assembly_type)
+        time.sleep(1)
+        #发送电池压制力
+        self._unilab_send_msg_assembly_pressure(assembly_pressure)
+        time.sleep(1)
        self._unilab_send_msg_succ_cmd(True)
        time.sleep(1)
        while (self.request_rec_msg_status) == True: 
@@ -697,6 +708,23 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
        print("data_electrolyte_code", data_electrolyte_code)
        print("data_coin_cell_code", data_coin_cell_code)
        #接收完信息后，读取完毕标志位置True
+        liaopan3 = self.station_resource.get_resource("\u7535\u6c60\u6599\u76d8")        
+        #把物料解绑后放到另一盘上
+        battery = ElectrodeSheet(name=f"battery_{self.coin_num_N}", size_x=14, size_y=14, size_z=2)
+        battery._unilabos_state = {
+                            "electrolyte_name": data_coin_cell_code,
+                            "data_electrolyte_code": data_electrolyte_code,
+                            "open_circuit_voltage": data_open_circuit_voltage,
+                            "assembly_pressure": data_assembly_pressure,
+                            "electrolyte_volume": data_electrolyte_volume
+                            }
+        liaopan3.children[self.coin_num_N].assign_child_resource(battery, location=None)
+        #print(jipian2.parent)
+        ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
+            "resources": [self.station_resource]
+        })
+
+
        self._unilab_rec_msg_succ_cmd(True)
        time.sleep(1)
        #等待允许读取标志位置False
@@ -756,7 +784,8 @@ class CoinCellAssemblyWorkstation(WorkstationBase):



-    def func_allpack_cmd(self, elec_num, elec_use_num, file_path: str="D:\\coin_cell_data") -> bool:
+    def func_allpack_cmd(self, elec_num, elec_use_num, elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200, file_path: str="D:\\coin_cell_data") -> bool:
+        elec_num, elec_use_num, elec_vol, assembly_type, assembly_pressure = int(elec_num), int(elec_use_num), int(elec_vol), int(assembly_type), int(assembly_pressure)
        summary_csv_file = os.path.join(file_path, "duandian.csv")
        # 如果断点文件存在，先读取之前的进度
        if os.path.exists(summary_csv_file):
@@ -784,54 +813,38 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
            elec_num_N = 0
            elec_use_num_N = 0
            coin_num_N = 0
-
-        print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {elec_use_num}")
-
+        for i in range(20):
+            print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {elec_use_num}")
+            print(f"剩余电解液瓶数: {type(elec_num)}, 已组装电池数: {type(elec_use_num)}")
+            print(f"剩余电解液瓶数: {type(int(elec_num))}, 已组装电池数: {type(int(elec_use_num))}")
        
        #如果是第一次运行，则进行初始化、切换自动、启动, 如果是断点重启则跳过。
        if read_status_flag == False:
+            pass
            #初始化
-            self.func_pack_device_init()
+            #self.func_pack_device_init()
            #切换自动
-            self.func_pack_device_auto()
+            #self.func_pack_device_auto()
            #启动，小车收回
-            self.func_pack_device_start()
+            #self.func_pack_device_start()
            #发送电解液瓶数量，启动搬运,多搬运没事
-            self.func_pack_send_bottle_num(elec_num)
+            #self.func_pack_send_bottle_num(elec_num)
        last_i = elec_num_N
        last_j = elec_use_num_N
        for i in range(last_i, elec_num):
            print(f"开始第{last_i+i+1}瓶电解液的组装")
            #第一个循环从上次断点继续，后续循环从0开始
            j_start = last_j if i == last_i else 0
-            self.func_pack_send_msg_cmd(elec_use_num-j_start)
+            self.func_pack_send_msg_cmd(elec_use_num-j_start, elec_vol, assembly_type, assembly_pressure)

            for j in range(j_start, elec_use_num):
                print(f"开始第{last_i+i+1}瓶电解液的第{j+j_start+1}个电池组装")
                #读取电池组装数据并存入csv
                self.func_pack_get_msg_cmd(file_path)
                time.sleep(1)
-
-                #这里定义物料系统
                # TODO:读完再将电池数加一还是进入循环就将电池数加一需要考虑
-                liaopan1 = self.deck.get_resource("liaopan1")
-                liaopan4 = self.deck.get_resource("liaopan4")
-                jipian1 = liaopan1.children[coin_num_N].children[0]
-                jipian4 = liaopan4.children[coin_num_N].children[0]
-                #print(jipian1)
-                #从料盘上去物料解绑后放到另一盘上
-                jipian1.parent.unassign_child_resource(jipian1)
-                jipian4.parent.unassign_child_resource(jipian4)
-                
-                #print(jipian2.parent)
-                battery = Battery(name = f"battery_{coin_num_N}")
-                battery.assign_child_resource(jipian1, location=None)
-                battery.assign_child_resource(jipian4, location=None)
-                
-                zidanjia6 = self.deck.get_resource("zi_dan_jia6")

-                zidanjia6.children[0].assign_child_resource(battery, location=None)
-               
+

                # 生成断点文件
                # 生成包含elec_num_N、coin_num_N、timestamp的CSV文件
@@ -842,6 +855,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                    writer.writerow([elec_num, elec_use_num, elec_num_N, elec_use_num_N, coin_num_N, timestamp])
                    csvfile.flush()
                coin_num_N += 1
+                self.coin_num_N = coin_num_N
                elec_use_num_N += 1
            elec_num_N += 1
            elec_use_num_N = 0
@@ -878,34 +892,22 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
    
    def fun_wuliao_test(self) -> bool: 
        #找到data_init中构建的2个物料盘
-        #liaopan1 = self.deck.get_resource("liaopan1")
-        #liaopan4 = self.deck.get_resource("liaopan4")
-        #for coin_num_N in range(16):
-        #    liaopan1 = self.deck.get_resource("liaopan1")
-        #    liaopan4 = self.deck.get_resource("liaopan4")
-        #    jipian1 = liaopan1.children[coin_num_N].children[0]
-        #    jipian4 = liaopan4.children[coin_num_N].children[0]
-        #    #print(jipian1)
-        #    #从料盘上去物料解绑后放到另一盘上
-        #    jipian1.parent.unassign_child_resource(jipian1)
-        #    jipian4.parent.unassign_child_resource(jipian4)
-        #    
-        #    #print(jipian2.parent)
-        #    battery = Battery(name = f"battery_{coin_num_N}")
-        #    battery.assign_child_resource(jipian1, location=None)
-        #    battery.assign_child_resource(jipian4, location=None)
-        #    
-        #    zidanjia6 = self.deck.get_resource("zi_dan_jia6")
-        #    zidanjia6.children[0].assign_child_resource(battery, location=None)
-        #    ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
-        #        "resources": [self.deck]
-        #    })
-        #    time.sleep(2)
-        for i in range(20):
-            print(f"输出{i}")
-            time.sleep(2)
-
+        liaopan3 = self.station_resource.get_resource("\u7535\u6c60\u6599\u76d8")
+        for i in range(16):            
+            battery = ElectrodeSheet(name=f"battery_{i}", size_x=16, size_y=16, size_z=2)
+            battery._unilabos_state = {
+                                "diameter": 20.0,
+                                "height": 20.0,
+                                "assembly_pressure": i,
+                                "electrolyte_volume": 20.0,
+                                "electrolyte_name": f"DP{i}"
+                                }
+            liaopan3.children[i].assign_child_resource(battery, location=None)
            
+            ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
+                "resources": [self.station_resource]
+            })
+            time.sleep(4)
    # 数据读取与输出
    def func_read_data_and_output(self, file_path: str="D:\\coin_cell_data"):
        # 检查CSV导出是否正在运行，已运行则跳出，防止同时启动两个while循环
@@ -1012,7 +1014,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
        #    else:
        #        print("子弹夹洞位0没有极片")
        #  
-        #    #把电解液从瓶中取到电池夹子中
+        #    # TODO:#把电解液从瓶中取到电池夹子中
        #    battery_site = deck.get_resource("battery_press_1")
        #    clip_magazine_battery = deck.get_resource("clip_magazine_battery")
        #    if battery_site.has_battery():
@@ -1119,24 +1121,52 @@ if __name__ == "__main__":
    #print("success")
    #创建一个物料台面

-    #deck = create_a_coin_cell_deck()
+    deck = create_a_coin_cell_deck()
+    #deck = create_a_full_coin_cell_deck()
+

    ##在台面上找到料盘和极片
    #liaopan1 = deck.get_resource("liaopan1")
    #liaopan2 = deck.get_resource("liaopan2")
    #jipian1 = liaopan1.children[1].children[0]
-#
-    ##print(jipian1)
+##
+    #print(jipian1)
    ##把物料解绑后放到另一盘上
    #jipian1.parent.unassign_child_resource(jipian1)
    #liaopan2.children[1].assign_child_resource(jipian1, location=None)
    ##print(jipian2.parent)
+    
+    liaopan1 = deck.get_resource("liaopan1")
+    liaopan2 = deck.get_resource("liaopan2")
+    for i in range(16):
+        #找到liaopan1上每一个jipian
+        jipian_linshi = liaopan1.children[i].children[0]
+        #把物料解绑后放到另一盘上
+        print("极片:", jipian_linshi)
+        jipian_linshi.parent.unassign_child_resource(jipian_linshi)
+        liaopan2.children[i].assign_child_resource(jipian_linshi, location=None)
+
+
    from unilabos.resources.graphio import resource_ulab_to_plr, convert_resources_to_type
+    #with open("./button_battery_station_resources_unilab.json", "r", encoding="utf-8") as f:
+    #    bioyond_resources_unilab = json.load(f)
+    #print(f"成功读取 JSON 文件，包含 {len(bioyond_resources_unilab)} 个资源")
+    #ulab_resources = convert_resources_to_type(bioyond_resources_unilab, List[PLRResource])
+    #print(f"转换结果类型: {type(ulab_resources)}")
+    #print(ulab_resources)

-    with open("./button_battery_decks_unilab.json", "r", encoding="utf-8") as f:
-        bioyond_resources_unilab = json.load(f)
-    print(f"成功读取 JSON 文件，包含 {len(bioyond_resources_unilab)} 个资源")
-    ulab_resources = convert_resources_to_type(bioyond_resources_unilab, List[PLRResource])
-    print(f"转换结果类型: {type(ulab_resources)}")
-    print(ulab_resources)

+
+    from unilabos.resources.graphio import convert_resources_from_type
+    from unilabos.config.config import BasicConfig 
+    BasicConfig.ak = "beb0c15f-2279-46a1-aba5-00eaf89aef55"
+    BasicConfig.sk = "15d4f25e-3512-4f9c-9bfb-43ab85e7b561"
+    from unilabos.app.web.client import http_client
+
+    resources = convert_resources_from_type([deck], [Resource])
+    json.dump({"nodes": resources, "links": []}, open("button_battery_station_resources_unilab.json", "w"), indent=2)
+   
+    #print(resources)
+    http_client.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
+ 
+    http_client.resource_add(resources)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
h840473807	5805f94e9a	扣电驱动中增加多个组装参数，更新驱动与注册表 (#120 ) 扣电驱动中增加多个组装参数，elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200，更新驱动与注册表	2025-10-21 16:27:02 +08:00
Calvin Cao	3adcc41ce8	Merge pull request #118 from h840473807/workstation_dev_YB2 Workstation dev yb2	2025-10-21 10:32:41 +08:00
h840473807	243922caf4	宜宾配液+扣电工站注册表文件宜宾配液+扣电工站注册表文件	2025-10-20 15:43:21 +08:00
h840473807	079ec9d1b4	workstation_by_hhm 宜宾扣电工站与奔曜配液工站，更新截止10月20日	2025-10-20 15:36:53 +08:00
ZiWei	54cfaf15f3	Workstation dev yb2 (#100 ) * Refactor and extend reaction station action messages * Refactor dispensing station tasks to enhance parameter clarity and add batch processing capabilities - Updated `create_90_10_vial_feeding_task` to include detailed parameters for 90%/10% vial feeding, improving clarity and usability. - Introduced `create_batch_90_10_vial_feeding_task` for batch processing of 90%/10% vial feeding tasks with JSON formatted input. - Added `create_batch_diamine_solution_task` for batch preparation of diamine solution, also utilizing JSON formatted input. - Refined `create_diamine_solution_task` to include additional parameters for better task configuration. - Enhanced schema descriptions and default values for improved user guidance.	2025-10-10 15:25:50 +08:00
Junhan Chang	1c9d2ee98a	fix bioyond resource io	2025-09-30 17:02:38 +08:00
Junhan Chang	3fe8f4ca44	add child_size for itemized_carrier	2025-09-30 12:58:42 +08:00
Junhan Chang	2476821dcc	update bioyond launch json	2025-09-30 12:25:21 +08:00
Junhan Chang	7b426ed5ae	create warehouse by factory func	2025-09-30 11:57:34 +08:00
Junhan Chang	9bbae96447	Merge branch 'workstation_dev_YB2' of https://github.com/dptech-corp/Uni-Lab-OS into workstation_dev_YB2	2025-09-29 21:02:05 +08:00
Junhan Chang	10aabb7592	refactor: add itemized_carrier instead of carrier consists of ResourceHolder	2025-09-29 20:36:45 +08:00
Junhan Chang	a5397ffe12	create/update resources with POST/PUT for big amount/ small amount data	2025-09-26 23:25:34 +08:00
Junhan Chang	196e0f7e2b	fix bioyond station and registry	2025-09-26 08:12:41 +08:00
Junhan Chang	a632fd495e	bioyond station with communication init and resource sync	2025-09-25 20:56:29 +08:00
Junhan Chang	a8cc02a126	add bioyond studio draft	2025-09-25 20:36:52 +08:00
Xie Qiming	ad2e1432c6	feat: 将新威电池测试系统驱动与配置文件并入 workstation_dev_YB2 (#92 ) * feat: 新威电池测试系统驱动与注册文件 * feat: bring neware driver & battery.json into workstation_dev_YB2	2025-09-25 18:53:04 +08:00
Junhan Chang	c3b9583eac	fix: update resource with correct structure; remove deprecated liquid_handler set_group action	2025-09-25 15:27:05 +08:00
Junhan Chang	5c47cd0c8a	add BIOYOND deck assignment and pass all tests	2025-09-25 08:41:41 +08:00
Junhan Chang	63ab1af45d	refactor and add BIOYOND resources tests	2025-09-25 08:14:48 +08:00
Junhan Chang	a8419dc0c3	add standardized BIOYOND resources: bottle_carrier, bottle	2025-09-25 03:49:07 +08:00
Junhan Chang	34f05f2e25	refactor: rename "station_resource" to "deck"	2025-09-24 10:53:11 +08:00
h840473807	0dc2488f02	coin_cell_station draft	2025-09-23 01:18:04 +08:00
Junhan Chang	f13156e792	fix dict to tree/nested-dict converter	2025-09-23 00:02:45 +08:00
Xuwznln	13fd1ac572	更新物料接口	2025-09-22 17:14:48 +08:00
Guangxin Zhang	f8ef6e0686	Add Defaultlayout	2025-09-19 19:34:25 +01:00
Xuwznln	94a7b8aaca	Update install md	2025-09-19 23:02:46 +08:00
Xuwznln	301bea639e	修复protocolnode的兼容性	2025-09-19 22:54:27 +08:00
Xuwznln	4b5a83efa4	修复protocolnode的兼容性	2025-09-19 21:09:07 +08:00
Xuwznln	2889e9be2c	更新所有注册表	2025-09-19 20:28:43 +08:00
Xuwznln	304aebbba7	bump version to 0.10.6	2025-09-19 19:55:34 +08:00
Xuwznln	091c9fa247	Merge branch 'workstation_dev' into dev # Conflicts: # .conda/recipe.yaml # recipes/msgs/recipe.yaml # recipes/unilabos/recipe.yaml # setup.py # unilabos/registry/devices/work_station.yaml # unilabos/ros/nodes/base_device_node.py # unilabos/ros/nodes/presets/protocol_node.py # unilabos_msgs/package.xml	2025-09-19 19:52:53 +08:00
Xuwznln	67ca45a240	remove class for resource	2025-09-19 19:33:28 +08:00
Xuwznln	7aab2ea493	fix resource download	2025-09-19 19:17:03 +08:00
Xuwznln	62f3a6d696	PRCXI9320 json	2025-09-19 17:14:43 +08:00
Xuwznln	eb70ad0e18	PRCXI9320 json	2025-09-19 16:52:12 +08:00
Xuwznln	768f43880e	PRCXI9320 json	2025-09-19 16:29:18 +08:00
Xuwznln	762c3c737c	重新补全zhida注册表	2025-09-19 11:45:57 +08:00
Xie Qiming	ace98a4472	Feature/xprbalance-zhida (#80 ) * feat(devices): add Zhida GC/MS pretreatment automation workstation * feat(devices): add mettler_toledo xpr balance * balance	2025-09-19 11:43:25 +08:00
Xuwznln	41eaa88c6f	修复移液站错误的aspirate注册表	2025-09-19 07:05:09 +08:00
Xuwznln	a1a55a2c0a	fix resource_add	2025-09-19 06:25:28 +08:00
Xuwznln	2eaa0ca729	try fix add protocol	2025-09-19 06:21:29 +08:00
Xuwznln	6f8f070f40	fix protocol node log_message, added create_resource return value	2025-09-19 05:36:47 +08:00
Xuwznln	da4bd927e0	fix protocol node log_message, added create_resource return value	2025-09-19 05:31:49 +08:00
Xuwznln	01f8816597	update registry with nested obj	2025-09-19 03:44:18 +08:00
Guangxin Zhang	e5006285df	重新规定了版位推荐的入参	2025-09-18 15:27:22 +01:00
Guangxin Zhang	573c724a5c	新增版位推荐功能	2025-09-17 21:07:19 +01:00
Xuwznln	09549d2839	resource_update use resource_add	2025-09-18 03:47:26 +08:00
Junhan Chang	50c7777cea	Fix: run-column with correct vessel id (#86 ) * fix run_column * Update run_column_protocol.py (cherry picked from commit `e5aa4d940a`)	2025-09-16 14:40:16 +08:00
Xuwznln	4888f02c09	add server timeout	2025-09-16 09:47:06 +08:00
Xuwznln	779c9693d9	refactor ws client	2025-09-16 05:24:42 +08:00
Xuwznln	ffa841a41a	fix dupe upload registry	2025-09-15 16:25:41 +08:00
Xuwznln	fc669f09f8	fix import error	2025-09-15 15:55:44 +08:00
Xuwznln	2ca0311de6	移除MQTT，更新launch文档，提供注册表示例文件，更新到0.10.5	2025-09-15 02:39:43 +08:00
Guangxin Zhang	94cdcbf24e	对于PRCXI9320的transfer_group，一对多和多对多	2025-09-15 00:29:16 +08:00
Xuwznln	1cd07915e7	Correct runze pump multiple receive method.	2025-09-14 03:17:50 +08:00
Xuwznln	b600fc666d	Correct runze pump multiple receive method.	2025-09-14 03:07:48 +08:00
Xuwznln	9e214c56c1	Update runze_multiple_backbone	2025-09-14 01:04:50 +08:00
Xuwznln	bdf27a7e82	Correct runze multiple backbone	2025-09-14 00:40:29 +08:00
Xuwznln	2493fb9f94	Update runze pump format	2025-09-14 00:22:39 +08:00
Xuwznln	c7a0ff67a9	support multiple backbone (cherry picked from commit `4771ff2347`)	2025-09-14 00:21:54 +08:00
Xuwznln	711a7c65fa	remove runze multiple software obtainer (cherry picked from commit `8bcc92a394`)	2025-09-14 00:21:53 +08:00
Xuwznln	cde7956896	runze multiple pump support (cherry picked from commit `49354fcf39`)	2025-09-14 00:21:52 +08:00
Xuwznln	95b6fd0451	新增uat的地址替换	2025-09-11 16:38:17 +08:00
Xuwznln	513e848d89	result_info改为字典类型	2025-09-11 16:24:53 +08:00
Guangxin Zhang	58d1cc4720	Add set_group and transfer_group methods to PRCXI9300Handler and update liquid_handler.yaml	2025-09-10 21:23:15 +08:00
Guangxin Zhang	5676dd6589	Add LiquidHandlerSetGroup and LiquidHandlerTransferGroup actions to CMakeLists	2025-09-10 20:57:22 +08:00
Guangxin Zhang	1ae274a833	Add action definitions for LiquidHandlerSetGroup and LiquidHandlerTransferGroup - Created LiquidHandlerSetGroup.action with fields for group name, wells, and volumes. - Created LiquidHandlerTransferGroup.action with fields for source and target group names and unit volume. - Both actions include response fields for return information and success status.	2025-09-10 20:57:16 +08:00
Xuwznln	22b88c8441	取消labid 和强制config输入	2025-09-10 20:55:24 +08:00
Xuwznln	81bcc1907d	fix: addr param	2025-09-10 20:14:33 +08:00
Xuwznln	8cffd3dc21	fix: addr param	2025-09-10 20:13:44 +08:00
Xuwznln	a722636938	增加addr参数	2025-09-10 20:01:10 +08:00
Xuwznln	f68340d932	修复status密集发送时，消息出错	2025-09-10 18:52:23 +08:00
Xuwznln	361eae2f6d	注册表编辑器	2025-09-07 20:57:48 +08:00
Xuwznln	c25283ae04	主机节点信息等支持自动刷新	2025-09-07 12:53:00 +08:00
Xuwznln	961752fb0d	更新schema的title字段	2025-09-07 00:43:23 +08:00
Xuwznln	55165024dd	修复async错误	2025-09-04 20:19:15 +08:00
Xuwznln	6ddceb8393	修复edge上报错误	2025-09-04 19:31:19 +08:00
Xuwznln	4e52c7d2f4	修复event loop错误	2025-09-04 17:11:50 +08:00
Xuwznln	0b56efc89d	增加handle检测，增加material edge关系上传	2025-09-04 16:46:25 +08:00
Xuwznln	a27b93396a	修复工站的tracker实例追踪失效问题	2025-09-04 02:51:13 +08:00
Xuwznln	2a60a6c27e	修正物料关系上传	2025-09-03 14:20:37 +08:00
Xuwznln	5dda94044d	增加物料关系上传日志	2025-09-03 12:31:25 +08:00
Xuwznln	0cfc6f45e3	增加物料关系上传日志	2025-09-03 12:20:54 +08:00
Xuwznln	831f4549f9	ws protocol	2025-09-02 18:51:27 +08:00
Xuwznln	f4d4eb06d3	ws test version 2	2025-09-02 18:29:05 +08:00
Xuwznln	e3b8164f6b	ws test version 1	2025-09-02 14:32:02 +08:00
Xuwznln	78c04acc2e	fix: missing job_id key	2025-09-01 16:34:23 +08:00
Xuwznln	cd0428ea78	fix: build	2025-08-30 12:24:28 +08:00
Xuwznln	bdddbd57ba	fix: 还原protocol node处理方法	2025-08-30 12:22:46 +08:00
Xuwznln	a312de08a5	fix: station自己的方法注册错误	2025-08-30 12:20:24 +08:00
Xuwznln	68513b5745	feat: action status	2025-08-29 15:38:16 +08:00
Xuwznln	19027350fb	feat: workstation example	2025-08-29 02:47:20 +08:00
Xuwznln	bbbdb06bbc	feat: websocket test	2025-08-28 19:57:14 +08:00
Xuwznln	cd84e26126	feat: websocket	2025-08-28 14:34:38 +08:00
Junhan Chang	ce5bab3af1	example for use WorkstationBase	2025-08-27 15:20:20 +08:00
Junhan Chang	82d9ef6bf7	uncompleted refactor	2025-08-27 15:19:58 +08:00
Junhan Chang	332b33c6f4	simplify resource system	2025-08-27 11:13:56 +08:00
ZiWei	1ec642ee3a	update: Workstation dev 将版本号从 0.10.3 更新为 0.10.4 (#84 ) * Add:msgs.action * update: 将版本号从 0.10.3 更新为 0.10.4	2025-08-27 01:55:28 +08:00
ZiWei	7d8e6d029b	Add:msgs.action (#83 )	2025-08-27 01:21:13 +08:00
Junhan Chang	5ec8a57a1f	refactor: ProtocolNode→WorkstationNode	2025-08-25 22:09:37 +08:00
Junhan Chang	ae3c1100ae	refactor: workstation_base 重构为仅含业务逻辑，通信和子设备管理交给 ProtocolNode	2025-08-22 06:43:43 +08:00
Junhan Chang	14bc2e6cda	Create workstation_architecture.md	2025-08-21 10:09:57 +08:00
Junhan Chang	9f823a4198	update workstation base	2025-08-21 10:05:58 +08:00
Xuwznln	02c79363c1	feat: add sk & ak	2025-08-20 21:23:08 +08:00
Junhan Chang	227ff1284a	add workstation template and battery example	2025-08-19 21:35:27 +08:00
Xuwznln	4b7bde6be5	Update recipe.yaml	2025-08-13 16:36:53 +08:00
Xuwznln	8a669ac35a	fix: figure_resource	2025-08-13 13:23:02 +08:00
Junhan Chang	a1538da39e	use call_async in all service to avoid deadlock	2025-08-13 04:25:51 +08:00
Xuwznln	0063df4cf3	fix: prcxi import error	2025-08-12 19:31:52 +08:00
Xuwznln	e570ba4976	临时兼容错误的driver写法	2025-08-12 19:20:53 +08:00
Xuwznln	e8c1f76dbb	fix protocol node	2025-08-12 17:08:59 +08:00
Junhan Chang	f791c1a342	fix filter protocol	2025-08-12 16:48:32 +08:00
Junhan Chang	ea60cbe891	bugfixes on organic protocols	2025-08-12 14:50:01 +08:00
Junhan Chang	eac9b8ab3d	fix and remove redundant info	2025-08-11 20:52:03 +08:00
Xuwznln	573bcf1a6c	feat: 新增use_remote_resource参数	2025-08-11 16:09:27 +08:00
Junhan Chang	50e93cb1af	fix all protocol_compilers and remove deprecated devices	2025-08-11 15:01:04 +08:00
Xuwznln	fe1a029a9b	feat: 优化protocol node节点运行日志	2025-08-10 17:31:44 +08:00
Junhan Chang	662c063f50	fix pumps and liquid_handler handle	2025-08-07 20:59:57 +08:00
Xuwznln	01cbbba0b3	feat: workstation example	2025-08-07 15:26:17 +08:00
Xuwznln	e6c556cf19	add: prcxi res fix: startup slow	2025-08-07 01:26:33 +08:00
Xuwznln	0605f305ed	fix: prcxi_res	2025-08-06 23:06:22 +08:00
Xuwznln	37d8108ec4	fix: discard_tips	2025-08-06 19:27:10 +08:00
Xuwznln	6081dac561	fix: discard_tips error	2025-08-06 19:18:35 +08:00
Xuwznln	5b2d066127	fix: drop_tips not using auto resource select	2025-08-06 19:10:04 +08:00
ZiWei	06e66765e7	feat: 添加ChinWe设备控制类，支持串口通信和电机控制功能 (#79 )	2025-08-06 18:49:37 +08:00
Xuwznln	98ce360088	feat: add trace log level	2025-08-04 20:27:02 +08:00
Xuwznln	5cd0f72fbd	modify default discovery_interval to 15s	2025-08-04 14:10:43 +08:00
Xuwznln	343f394203	fix: working dir error when input config path feat: report publish topic when error	2025-08-04 14:04:31 +08:00
Junhan Chang	46aa7a7bd2	fix: workstation handlers and vessel_id parsing	2025-08-04 10:24:42 +08:00
Junhan Chang	a66369e2c3	Cleanup registry to be easy-understanding (#76 ) * delete deprecated mock devices * rename categories * combine chromatographic devices * rename rviz simulation nodes * organic virtual devices * parse vessel_id * run registry completion before merge --------- Co-authored-by: Xuwznln <18435084+Xuwznln@users.noreply.github.com>	2025-08-03 11:21:37 +08:00