Merge pull request #177 from sun7151887/yb4-fix

Yb4默认仿真机

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

@@ -42,7 +42,7 @@ jobs:
     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}' }}
+        shell: ${{ matrix.platform == 'win-64' && 'cmd' || 'bash' }}
 
     steps:
       - name: Check if platform should be built
@@ -73,7 +73,6 @@ jobs:
           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
 
@@ -82,7 +81,7 @@ jobs:
         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
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
 
       - name: Install conda-pack, unilabos and dependencies (Unix)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform != 'win-64'
@@ -90,15 +89,15 @@ jobs:
         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
+          mamba install -n unilab uni-lab::unilabos conda-pack -c uni-lab -c robostack-staging -c conda-forge -y
 
       - name: Get latest ros-humble-unilabos-msgs version (Windows)
         if: steps.should_build.outputs.should_build == 'true' && matrix.platform == 'win-64'
         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
+          conda list -n unilab ros-humble-unilabos-msgs
+          for /f "tokens=2" %%i in ('conda list -n unilab 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%
 
@@ -108,7 +107,7 @@ jobs:
         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')")
+          VERSION=$(conda list -n unilab 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"
 
@@ -119,7 +118,7 @@ jobs:
           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
+          mamba update -n unilab 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'
@@ -129,65 +128,65 @@ jobs:
           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"
+          mamba update -n unilab 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
+          mamba run -n unilab pip uninstall unilabos -y || echo unilabos not installed via pip
           echo Installing unilabos from source (branch: ${{ github.event.inputs.branch }})...
-          pip install .
+          mamba run -n unilab pip install .
           echo Verifying installation...
-          pip show unilabos
+          mamba run -n unilab 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"
+          mamba run -n unilab pip uninstall unilabos -y || echo "unilabos not installed via pip"
           echo "Installing unilabos from source (branch: ${{ github.event.inputs.branch }})..."
-          pip install .
+          mamba run -n unilab pip install .
           echo "Verifying installation..."
-          pip show unilabos
+          mamba run -n unilab 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
+          mamba env list
           echo.
           echo === Installed Packages ===
-          conda list | findstr /C:"unilabos" /C:"ros-humble-unilabos-msgs" || conda list
+          mamba list -n unilab | findstr /C:"unilabos" /C:"ros-humble-unilabos-msgs" || mamba list -n unilab
           echo.
           echo === Python Packages ===
-          pip list | findstr unilabos || pip list
+          mamba run -n unilab pip list | findstr unilabos || mamba run -n unilab 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
+          mamba env list
           echo ""
           echo "=== Installed Packages ==="
-          conda list | grep -E "(unilabos|ros-humble-unilabos-msgs)" || conda list
+          mamba list -n unilab | grep -E "(unilabos|ros-humble-unilabos-msgs)" || mamba list -n unilab
           echo ""
           echo "=== Python Packages ==="
-          pip list | grep unilabos || pip list
+          mamba run -n unilab pip list | grep unilabos || mamba run -n unilab 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}')"
+          mamba run -n unilab 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
+          mamba run -n unilab 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')"
+          mamba run -n unilab python -c "import rclpy; print('ROS2 rclpy: OK')"
           echo Running comprehensive verification script...
-          python scripts\verify_installation.py || echo Warning: Verification script reported issues
+          mamba run -n unilab python scripts\verify_installation.py --auto-install || echo Warning: Verification script reported issues
           echo Environment verification complete!
 
       - name: Verify environment integrity (Unix)
@@ -195,20 +194,20 @@ jobs:
         shell: bash
         run: |
           echo "Verifying Python version..."
-          python -c "import sys; print(f'Python version: {sys.version}')"
+          mamba run -n unilab 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"
+          mamba run -n unilab 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')"
+          mamba run -n unilab python -c "import rclpy; print('ROS2 rclpy: OK')"
           echo "Running comprehensive verification script..."
-          python scripts/verify_installation.py || echo "Warning: Verification script reported issues"
+          mamba run -n unilab python scripts/verify_installation.py --auto-install || 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
+          mamba activate unilab && 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
 
@@ -217,6 +216,7 @@ jobs:
         shell: bash
         run: |
           echo "Packing unilab environment with conda-pack..."
+          mamba install conda-pack -c conda-forge -y
           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
@@ -242,6 +242,10 @@ jobs:
           echo Adding: verify_installation.py
           copy scripts\verify_installation.py dist-package\
 
+          rem Copy source code repository (including .git)
+          echo Adding: Uni-Lab-OS source repository
+          robocopy . dist-package\Uni-Lab-OS /E /XD dist-package /NFL /NDL /NJH /NJS /NC /NS || if %ERRORLEVEL% LSS 8 exit /b 0
+
           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
@@ -274,6 +278,10 @@ jobs:
           echo "Adding: verify_installation.py"
           cp scripts/verify_installation.py dist-package/
 
+          # Copy source code repository (including .git)
+          echo "Adding: Uni-Lab-OS source repository"
+          rsync -a --exclude='dist-package' . dist-package/Uni-Lab-OS
+
           # Create README using Python script
           echo "Creating: README.txt"
           python scripts/create_readme.py ${{ matrix.platform }} ${{ github.event.inputs.branch }} dist-package/README.txt
@@ -283,46 +291,6 @@ jobs:
           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
@@ -365,12 +333,8 @@ jobs:
           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 "  install_unilab.sh"
           echo "=========================================="

.github/workflows/deploy-docs.yml

@@ -39,24 +39,39 @@ jobs:
         uses: actions/checkout@v4
         with:
           ref: ${{ github.event.inputs.branch || github.ref }}
+          fetch-depth: 0
 
-      - name: Setup Python environment
-        uses: actions/setup-python@v5
+      - name: Setup Miniforge (with mamba)
+        uses: conda-incubator/setup-miniconda@v3
         with:
-          python-version: '3.10'
+          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-update-conda: false
+          show-channel-urls: true
 
-      - name: Install system dependencies
+      - name: Install unilabos and dependencies
         run: |
-          sudo apt-get update
-          sudo apt-get install -y pandoc
+          echo "Installing unilabos and dependencies to unilab environment..."
+          echo "Using mamba for faster and more reliable dependency resolution..."
+          mamba install -n unilab uni-lab::unilabos -c uni-lab -c robostack-staging -c conda-forge -y
 
-      - name: Install Python dependencies
+      - name: Install latest unilabos from source
         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
+          echo "Uninstalling existing unilabos..."
+          mamba run -n unilab pip uninstall unilabos -y || echo "unilabos not installed via pip"
+          echo "Installing unilabos from source..."
+          mamba run -n unilab pip install .
+          echo "Verifying installation..."
+          mamba run -n unilab pip show unilabos
+
+      - name: Install documentation dependencies
+        run: |
+          echo "Installing documentation build dependencies..."
+          mamba run -n unilab pip install -r docs/requirements.txt
 
       - name: Setup Pages
         id: pages
@@ -68,8 +83,8 @@ jobs:
           cd docs
           # Clean previous builds
           rm -rf _build
-          # Build HTML documentation
-          python -m sphinx -b html . _build/html -v
+          # Build HTML documentation in conda environment
+          mamba run -n unilab python -m sphinx -b html . _build/html -v
 
       - name: Check build results
         run: |

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://xuwznln.github.io/Uni-Lab-OS-Doc/)
 
 ## 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://xuwznln.github.io/Uni-Lab-OS-Doc/boot_examples/index.html)
 
 ## Message Format
 

README_zh.md

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

docs/boot_examples/organic_synthesis.md

@@ -91,7 +91,7 @@
 使用以下命令启动模拟反应器：
 
 ```bash
-unilab -g test/experiments/mock_reactor.json --app_bridges ""
+unilab -g test/experiments/mock_reactor.json
 ```
 
 ### 2. 执行抽真空和充气操作

docs/conf.py

@@ -23,7 +23,7 @@ extensions = [
     "myst_parser",
     "sphinx.ext.autodoc",
     "sphinx.ext.napoleon",  # 如果您使用 Google 或 NumPy 风格的 docstrings
-    "sphinx_rtd_theme"
+    "sphinx_rtd_theme",
 ]
 
 source_suffix = {

new_cellconfig.json

@@ -0,0 +1,54 @@
+{
+  "nodes": [
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "parent": null,
+      "children": [
+        "coin_cell_deck"
+      ],
+      "type": "device",
+      "class":"coincellassemblyworkstation_device",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_YH_Deck",
+            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
+          }
+        },
+        "debug_mode": true,
+        "protocol_type": []
+      }
+    },
+    {
+      "id": "YB_YH_Deck",
+      "name": "YB_YH_Deck",
+      "children": [],
+      "parent": "BatteryStation",
+      "type": "deck",
+      "class": "CoincellDeck",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "CoincellDeck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    }
+  ],
+  "links": []
+}

new_cellconfig3c.json

@@ -0,0 +1,98 @@
+      
+{
+  "nodes": [
+    {
+      "id": "bioyond_cell_workstation",
+      "name": "配液分液工站",
+      "parent": null,
+      "children": [
+        "YB_Bioyond_Deck"
+      ],
+      "type": "device",
+      "class": "bioyond_cell",
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_Bioyond_Deck",
+            "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
+          }
+        },
+        "protocol_type": []
+      },
+      "data": {}
+    },
+    {
+      "id": "YB_Bioyond_Deck",
+      "name": "YB_Bioyond_Deck",
+      "children": [],
+      "parent": "bioyond_cell_workstation",
+      "type": "deck",
+      "class": "BIOYOND_YB_Deck",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "BIOYOND_YB_Deck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    },
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "parent": null,
+      "children": [
+        "coin_cell_deck"
+      ],
+      "type": "device",
+      "class":"coincellassemblyworkstation_device",
+      "config": {
+        "deck": {
+          "data": {
+            "_resource_child_name": "YB_YH_Deck",
+            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
+          }
+        },
+        "protocol_type": []
+      },
+      "position": {
+        "size": {"height": 1450, "width": 1450, "depth": 2100},
+        "position": {
+          "x": -1500,
+          "y": 0,
+          "z": 0
+        }
+      }
+    },
+    {
+      "id": "YB_YH_Deck",
+      "name": "YB_YH_Deck",
+      "children": [],
+      "parent": "BatteryStation",
+      "type": "deck",
+      "class": "CoincellDeck",
+      "config": {
+        "type": "CoincellDeck",
+        "setup": true,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        }
+      },
+      "data": {}
+    }
+  ],
+  "links": []
+}
+
+    

scripts/create_readme.py

@@ -172,7 +172,7 @@ Examples:
         with open(output_path, "w", encoding="utf-8") as f:
             f.write(readme_content)
 
-        print(f"✓ README.txt created: {output_path}")
+        print(f"  README.txt created: {output_path}")
         print(f"  Platform: {args.platform}")
         print(f"  Branch:   {args.branch}")
 

scripts/verify_installation.py

@@ -8,7 +8,10 @@ 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
+    python verify_installation.py [--auto-install]
+
+    Options:
+        --auto-install    Automatically install missing packages
 
     Or in the conda environment:
     conda activate unilab
@@ -17,14 +20,15 @@ Usage:
 
 import sys
 import os
+import argparse
 
 # 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")
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")  # type: ignore
     except (AttributeError, OSError):
         pass
 
@@ -49,7 +53,7 @@ CHECK_MARK = "[OK]"
 CROSS_MARK = "[FAIL]"
 
 
-def check_package(package_name: str, display_name: str = None) -> bool:
+def check_package(package_name: str, display_name: str | None = None) -> bool:
     """
     Check if a package can be imported.
 
@@ -87,9 +91,25 @@ def check_python_version() -> bool:
 
 def main():
     """Run all verification checks."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="Verify UniLabOS installation",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--auto-install",
+        action="store_true",
+        help="Automatically install missing packages",
+    )
+    args = parser.parse_args()
+
     print("=" * 60)
     print("UniLabOS Installation Verification")
     print("=" * 60)
+    if args.auto_install:
+        print("Mode: Auto-install missing packages")
+    else:
+        print("Mode: Verification only")
     print()
 
     all_passed = True
@@ -113,14 +133,16 @@ def main():
 
         print(f"  {CHECK_MARK} UniLabOS installed")
 
-        # Check environment without auto-install (verification only)
+        # Check environment with optional auto-install
         # 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)
+        env_check_passed = check_environment(auto_install=args.auto_install, 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")
+            if not args.auto_install:
+                print("  Hint: Run with --auto-install to automatically install missing packages")
     except ImportError:
         print(f"  {CROSS_MARK} UniLabOS not installed")
         all_passed = False

scripts/workflow.py

@@ -0,0 +1,695 @@
+import json
+import logging
+import traceback
+import uuid
+import xml.etree.ElementTree as ET
+from typing import Any, Dict, List
+
+import networkx as nx
+import matplotlib.pyplot as plt
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleGraph:
+    """简单的有向图实现，用于构建工作流图"""
+
+    def __init__(self):
+        self.nodes = {}
+        self.edges = []
+
+    def add_node(self, node_id, **attrs):
+        """添加节点"""
+        self.nodes[node_id] = attrs
+
+    def add_edge(self, source, target, **attrs):
+        """添加边"""
+        edge = {"source": source, "target": target, **attrs}
+        self.edges.append(edge)
+
+    def to_dict(self):
+        """转换为工作流图格式"""
+        nodes_list = []
+        for node_id, attrs in self.nodes.items():
+            node_attrs = attrs.copy()
+            params = node_attrs.pop("parameters", {}) or {}
+            node_attrs.update(params)
+            nodes_list.append({"id": node_id, **node_attrs})
+
+        return {
+            "directed": True,
+            "multigraph": False,
+            "graph": {},
+            "nodes": nodes_list,
+            "links": self.edges,
+        }
+
+
+def extract_json_from_markdown(text: str) -> str:
+    """从markdown代码块中提取JSON"""
+    text = text.strip()
+    if text.startswith("```json\n"):
+        text = text[8:]
+    if text.startswith("```\n"):
+        text = text[4:]
+    if text.endswith("\n```"):
+        text = text[:-4]
+    return text
+
+
+def convert_to_type(val: str) -> Any:
+    """将字符串值转换为适当的数据类型"""
+    if val == "True":
+        return True
+    if val == "False":
+        return False
+    if val == "?":
+        return None
+    if val.endswith(" g"):
+        return float(val.split(" ")[0])
+    if val.endswith("mg"):
+        return float(val.split("mg")[0])
+    elif val.endswith("mmol"):
+        return float(val.split("mmol")[0]) / 1000
+    elif val.endswith("mol"):
+        return float(val.split("mol")[0])
+    elif val.endswith("ml"):
+        return float(val.split("ml")[0])
+    elif val.endswith("RPM"):
+        return float(val.split("RPM")[0])
+    elif val.endswith(" °C"):
+        return float(val.split(" ")[0])
+    elif val.endswith(" %"):
+        return float(val.split(" ")[0])
+    return val
+
+
+def refactor_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """统一的数据重构函数，根据操作类型自动选择模板"""
+    refactored_data = []
+
+    # 定义操作映射，包含生物实验和有机化学的所有操作
+    OPERATION_MAPPING = {
+        # 生物实验操作
+        "transfer_liquid": "SynBioFactory-liquid_handler.prcxi-transfer_liquid",
+        "transfer": "SynBioFactory-liquid_handler.biomek-transfer",
+        "incubation": "SynBioFactory-liquid_handler.biomek-incubation",
+        "move_labware": "SynBioFactory-liquid_handler.biomek-move_labware",
+        "oscillation": "SynBioFactory-liquid_handler.biomek-oscillation",
+        # 有机化学操作
+        "HeatChillToTemp": "SynBioFactory-workstation-HeatChillProtocol",
+        "StopHeatChill": "SynBioFactory-workstation-HeatChillStopProtocol",
+        "StartHeatChill": "SynBioFactory-workstation-HeatChillStartProtocol",
+        "HeatChill": "SynBioFactory-workstation-HeatChillProtocol",
+        "Dissolve": "SynBioFactory-workstation-DissolveProtocol",
+        "Transfer": "SynBioFactory-workstation-TransferProtocol",
+        "Evaporate": "SynBioFactory-workstation-EvaporateProtocol",
+        "Recrystallize": "SynBioFactory-workstation-RecrystallizeProtocol",
+        "Filter": "SynBioFactory-workstation-FilterProtocol",
+        "Dry": "SynBioFactory-workstation-DryProtocol",
+        "Add": "SynBioFactory-workstation-AddProtocol",
+    }
+
+    UNSUPPORTED_OPERATIONS = ["Purge", "Wait", "Stir", "ResetHandling"]
+
+    for step in data:
+        operation = step.get("action")
+        if not operation or operation in UNSUPPORTED_OPERATIONS:
+            continue
+
+        # 处理重复操作
+        if operation == "Repeat":
+            times = step.get("times", step.get("parameters", {}).get("times", 1))
+            sub_steps = step.get("steps", step.get("parameters", {}).get("steps", []))
+            for i in range(int(times)):
+                sub_data = refactor_data(sub_steps)
+                refactored_data.extend(sub_data)
+            continue
+
+        # 获取模板名称
+        template = OPERATION_MAPPING.get(operation)
+        if not template:
+            # 自动推断模板类型
+            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
+                template = f"SynBioFactory-liquid_handler.biomek-{operation}"
+            else:
+                template = f"SynBioFactory-workstation-{operation}Protocol"
+
+        # 创建步骤数据
+        step_data = {
+            "template": template,
+            "description": step.get("description", step.get("purpose", f"{operation} operation")),
+            "lab_node_type": "Device",
+            "parameters": step.get("parameters", step.get("action_args", {})),
+        }
+        refactored_data.append(step_data)
+
+    return refactored_data
+
+
+def build_protocol_graph(
+    labware_info: List[Dict[str, Any]], protocol_steps: List[Dict[str, Any]], workstation_name: str
+) -> SimpleGraph:
+    """统一的协议图构建函数，根据设备类型自动选择构建逻辑"""
+    G = SimpleGraph()
+    resource_last_writer = {}
+    LAB_NAME = "SynBioFactory"
+
+    protocol_steps = refactor_data(protocol_steps)
+
+    # 检查协议步骤中的模板来判断协议类型
+    has_biomek_template = any(
+        ("biomek" in step.get("template", "")) or ("prcxi" in step.get("template", ""))
+        for step in protocol_steps
+    )
+
+    if has_biomek_template:
+        # 生物实验协议图构建
+        for labware_id, labware in labware_info.items():
+            node_id = str(uuid.uuid4())
+
+            labware_attrs = labware.copy()
+            labware_id = labware_attrs.pop("id", labware_attrs.get("name", f"labware_{uuid.uuid4()}"))
+            labware_attrs["description"] = labware_id
+            labware_attrs["lab_node_type"] = (
+                "Reagent" if "Plate" in str(labware_id) else "Labware" if "Rack" in str(labware_id) else "Sample"
+            )
+            labware_attrs["device_id"] = workstation_name
+
+            G.add_node(node_id, template=f"{LAB_NAME}-host_node-create_resource", **labware_attrs)
+            resource_last_writer[labware_id] = f"{node_id}:labware"
+
+        # 处理协议步骤
+        prev_node = None
+        for i, step in enumerate(protocol_steps):
+            node_id = str(uuid.uuid4())
+            G.add_node(node_id, **step)
+
+            # 添加控制流边
+            if prev_node is not None:
+                G.add_edge(prev_node, node_id, source_port="ready", target_port="ready")
+            prev_node = node_id
+
+            # 处理物料流
+            params = step.get("parameters", {})
+            if "sources" in params and params["sources"] in resource_last_writer:
+                source_node, source_port = resource_last_writer[params["sources"]].split(":")
+                G.add_edge(source_node, node_id, source_port=source_port, target_port="labware")
+
+            if "targets" in params:
+                resource_last_writer[params["targets"]] = f"{node_id}:labware"
+
+        # 添加协议结束节点
+        end_id = str(uuid.uuid4())
+        G.add_node(end_id, template=f"{LAB_NAME}-liquid_handler.biomek-run_protocol")
+        if prev_node is not None:
+            G.add_edge(prev_node, end_id, source_port="ready", target_port="ready")
+
+    else:
+        # 有机化学协议图构建
+        WORKSTATION_ID = workstation_name
+
+        # 为所有labware创建资源节点
+        for item_id, item in labware_info.items():
+            # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
+            node_id = str(uuid.uuid4())
+
+            # 判断节点类型
+            if item.get("type") == "hardware" or "reactor" in str(item_id).lower():
+                if "reactor" not in str(item_id).lower():
+                    continue
+                lab_node_type = "Sample"
+                description = f"Prepare Reactor: {item_id}"
+                liquid_type = []
+                liquid_volume = []
+            else:
+                lab_node_type = "Reagent"
+                description = f"Add Reagent to Flask: {item_id}"
+                liquid_type = [item_id]
+                liquid_volume = [1e5]
+
+            G.add_node(
+                node_id,
+                template=f"{LAB_NAME}-host_node-create_resource",
+                description=description,
+                lab_node_type=lab_node_type,
+                res_id=item_id,
+                device_id=WORKSTATION_ID,
+                class_name="container",
+                parent=WORKSTATION_ID,
+                bind_locations={"x": 0.0, "y": 0.0, "z": 0.0},
+                liquid_input_slot=[-1],
+                liquid_type=liquid_type,
+                liquid_volume=liquid_volume,
+                slot_on_deck="",
+                role=item.get("role", ""),
+            )
+            resource_last_writer[item_id] = f"{node_id}:labware"
+
+        last_control_node_id = None
+
+        # 处理协议步骤
+        for step in protocol_steps:
+            node_id = str(uuid.uuid4())
+            G.add_node(node_id, **step)
+
+            # 控制流
+            if last_control_node_id is not None:
+                G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
+            last_control_node_id = node_id
+
+            # 物料流
+            params = step.get("parameters", {})
+            input_resources = {
+                "Vessel": params.get("vessel"),
+                "ToVessel": params.get("to_vessel"),
+                "FromVessel": params.get("from_vessel"),
+                "reagent": params.get("reagent"),
+                "solvent": params.get("solvent"),
+                "compound": params.get("compound"),
+                "sources": params.get("sources"),
+                "targets": params.get("targets"),
+            }
+
+            for target_port, resource_name in input_resources.items():
+                if resource_name and resource_name in resource_last_writer:
+                    source_node, source_port = resource_last_writer[resource_name].split(":")
+                    G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
+
+            output_resources = {
+                "VesselOut": params.get("vessel"),
+                "FromVesselOut": params.get("from_vessel"),
+                "ToVesselOut": params.get("to_vessel"),
+                "FiltrateOut": params.get("filtrate_vessel"),
+                "reagent": params.get("reagent"),
+                "solvent": params.get("solvent"),
+                "compound": params.get("compound"),
+                "sources_out": params.get("sources"),
+                "targets_out": params.get("targets"),
+            }
+
+            for source_port, resource_name in output_resources.items():
+                if resource_name:
+                    resource_last_writer[resource_name] = f"{node_id}:{source_port}"
+
+    return G
+
+
+def draw_protocol_graph(protocol_graph: SimpleGraph, output_path: str):
+    """
+    (辅助功能) 使用 networkx 和 matplotlib 绘制协议工作流图，用于可视化。
+    """
+    if not protocol_graph:
+        print("Cannot draw graph: Graph object is empty.")
+        return
+
+    G = nx.DiGraph()
+
+    for node_id, attrs in protocol_graph.nodes.items():
+        label = attrs.get("description", attrs.get("template", node_id[:8]))
+        G.add_node(node_id, label=label, **attrs)
+
+    for edge in protocol_graph.edges:
+        G.add_edge(edge["source"], edge["target"])
+
+    plt.figure(figsize=(20, 15))
+    try:
+        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
+    except Exception:
+        pos = nx.shell_layout(G)  # Fallback layout
+
+    node_labels = {node: data["label"] for node, data in G.nodes(data=True)}
+    nx.draw(
+        G,
+        pos,
+        with_labels=False,
+        node_size=2500,
+        node_color="skyblue",
+        node_shape="o",
+        edge_color="gray",
+        width=1.5,
+        arrowsize=15,
+    )
+    nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8, font_weight="bold")
+
+    plt.title("Chemical Protocol Workflow Graph", size=15)
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.close()
+    print(f"  - Visualization saved to '{output_path}'")
+
+
+from networkx.drawing.nx_agraph import to_agraph
+import re
+
+COMPASS = {"n","e","s","w","ne","nw","se","sw","c"}
+
+def _is_compass(port: str) -> bool:
+    return isinstance(port, str) and port.lower() in COMPASS
+
+def draw_protocol_graph_with_ports(protocol_graph, output_path: str, rankdir: str = "LR"):
+    """
+    使用 Graphviz 端口语法绘制协议工作流图。
+    - 若边上的 source_port/target_port 是 compass（n/e/s/w/...），直接用 compass。
+    - 否则自动为节点创建 record 形状并定义命名端口 <portname>。
+    最终由 PyGraphviz 渲染并输出到 output_path（后缀决定格式，如 .png/.svg/.pdf）。
+    """
+    if not protocol_graph:
+        print("Cannot draw graph: Graph object is empty.")
+        return
+
+    # 1) 先用 networkx 搭建有向图，保留端口属性
+    G = nx.DiGraph()
+    for node_id, attrs in protocol_graph.nodes.items():
+        label = attrs.get("description", attrs.get("template", node_id[:8]))
+        # 保留一个干净的“中心标签”，用于放在 record 的中间槽
+        G.add_node(node_id, _core_label=str(label), **{k:v for k,v in attrs.items() if k not in ("label",)})
+
+    edges_data = []
+    in_ports_by_node  = {}  # 收集命名输入端口
+    out_ports_by_node = {}  # 收集命名输出端口
+
+    for edge in protocol_graph.edges:
+        u = edge["source"]
+        v = edge["target"]
+        sp = edge.get("source_port")
+        tp = edge.get("target_port")
+
+        # 记录到图里（保留原始端口信息）
+        G.add_edge(u, v, source_port=sp, target_port=tp)
+        edges_data.append((u, v, sp, tp))
+
+        # 如果不是 compass，就按“命名端口”先归类，等会儿给节点造 record
+        if sp and not _is_compass(sp):
+            out_ports_by_node.setdefault(u, set()).add(str(sp))
+        if tp and not _is_compass(tp):
+            in_ports_by_node.setdefault(v, set()).add(str(tp))
+
+    # 2) 转为 AGraph，使用 Graphviz 渲染
+    A = to_agraph(G)
+    A.graph_attr.update(rankdir=rankdir, splines="true", concentrate="false", fontsize="10")
+    A.node_attr.update(shape="box", style="rounded,filled", fillcolor="lightyellow", color="#999999", fontname="Helvetica")
+    A.edge_attr.update(arrowsize="0.8", color="#666666")
+
+    # 3) 为需要命名端口的节点设置 record 形状与 label
+    #    左列 = 输入端口；中间 = 核心标签；右列 = 输出端口
+    for n in A.nodes():
+        node = A.get_node(n)
+        core = G.nodes[n].get("_core_label", n)
+
+        in_ports  = sorted(in_ports_by_node.get(n, []))
+        out_ports = sorted(out_ports_by_node.get(n, []))
+
+        # 如果该节点涉及命名端口，则用 record；否则保留原 box
+        if in_ports or out_ports:
+            def port_fields(ports):
+                if not ports:
+                    return " "  # 必须留一个空槽占位
+                # 每个端口一个小格子，<p> name
+                return "|".join(f"<{re.sub(r'[^A-Za-z0-9_:.|-]', '_', p)}> {p}" for p in ports)
+
+            left  = port_fields(in_ports)
+            right = port_fields(out_ports)
+
+            # 三栏：左(入) | 中(节点名) | 右(出)
+            record_label = f"{{ {left} | {core} | {right} }}"
+            node.attr.update(shape="record", label=record_label)
+        else:
+            # 没有命名端口：普通盒子，显示核心标签
+            node.attr.update(label=str(core))
+
+    # 4) 给边设置 headport / tailport
+    #    - 若端口为 compass：直接用 compass（e.g., headport="e"）
+    #    - 若端口为命名端口：使用在 record 中定义的 <port> 名（同名即可）
+    for (u, v, sp, tp) in edges_data:
+        e = A.get_edge(u, v)
+
+        # Graphviz 属性：tail 是源，head 是目标
+        if sp:
+            if _is_compass(sp):
+                e.attr["tailport"] = sp.lower()
+            else:
+                # 与 record label 中 <port> 名一致；特殊字符已在 label 中做了清洗
+                e.attr["tailport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(sp))
+
+        if tp:
+            if _is_compass(tp):
+                e.attr["headport"] = tp.lower()
+            else:
+                e.attr["headport"] = re.sub(r'[^A-Za-z0-9_:.|-]', '_', str(tp))
+
+        # 可选：若想让边更贴边缘，可设置 constraint/spline 等
+        # e.attr["arrowhead"] = "vee"
+
+    # 5) 输出
+    A.draw(output_path, prog="dot")
+    print(f"  - Port-aware workflow rendered to '{output_path}'")
+
+
+def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
+    """展平嵌套的XDL程序结构"""
+    flattened_operations = []
+    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
+
+    def extract_operations(element: ET.Element):
+        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
+            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
+                flattened_operations.append(element)
+
+        for child in element:
+            extract_operations(child)
+
+    for child in procedure_elem:
+        extract_operations(child)
+
+    return flattened_operations
+
+
+def parse_xdl_content(xdl_content: str) -> tuple:
+    """解析XDL内容"""
+    try:
+        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
+        root = ET.fromstring(xdl_content_cleaned)
+
+        synthesis_elem = root.find("Synthesis")
+        if synthesis_elem is None:
+            return None, None, None
+
+        # 解析硬件组件
+        hardware_elem = synthesis_elem.find("Hardware")
+        hardware = []
+        if hardware_elem is not None:
+            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
+
+        # 解析试剂
+        reagents_elem = synthesis_elem.find("Reagents")
+        reagents = []
+        if reagents_elem is not None:
+            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
+
+        # 解析程序
+        procedure_elem = synthesis_elem.find("Procedure")
+        if procedure_elem is None:
+            return None, None, None
+
+        flattened_operations = flatten_xdl_procedure(procedure_elem)
+        return hardware, reagents, flattened_operations
+
+    except ET.ParseError as e:
+        raise ValueError(f"Invalid XDL format: {e}")
+
+
+def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
+    """
+    将XDL XML格式转换为标准的字典格式
+
+    Args:
+        xdl_content: XDL XML内容
+
+    Returns:
+        转换结果，包含步骤和器材信息
+    """
+    try:
+        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
+        if hardware is None:
+            return {"error": "Failed to parse XDL content", "success": False}
+
+        # 将XDL元素转换为字典格式
+        steps_data = []
+        for elem in flattened_operations:
+            # 转换参数类型
+            parameters = {}
+            for key, val in elem.attrib.items():
+                converted_val = convert_to_type(val)
+                if converted_val is not None:
+                    parameters[key] = converted_val
+
+            step_dict = {
+                "operation": elem.tag,
+                "parameters": parameters,
+                "description": elem.get("purpose", f"Operation: {elem.tag}"),
+            }
+            steps_data.append(step_dict)
+
+        # 合并硬件和试剂为统一的labware_info格式
+        labware_data = []
+        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
+        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
+
+        return {
+            "success": True,
+            "steps": steps_data,
+            "labware": labware_data,
+            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
+        }
+
+    except Exception as e:
+        error_msg = f"XDL conversion failed: {str(e)}"
+        logger.error(error_msg)
+        return {"error": error_msg, "success": False}
+
+
+def create_workflow(
+    steps_info: str,
+    labware_info: str,
+    workflow_name: str = "Generated Workflow",
+    workstation_name: str = "workstation",
+    workflow_description: str = "Auto-generated workflow from protocol",
+) -> Dict[str, Any]:
+    """
+    创建工作流，输入数据已经是统一的字典格式
+
+    Args:
+        steps_info: 步骤信息 (JSON字符串，已经是list of dict格式)
+        labware_info: 实验器材和试剂信息 (JSON字符串，已经是list of dict格式)
+        workflow_name: 工作流名称
+        workflow_description: 工作流描述
+
+    Returns:
+        创建结果，包含工作流UUID和详细信息
+    """
+    try:
+        # 直接解析JSON数据
+        steps_info_clean = extract_json_from_markdown(steps_info)
+        labware_info_clean = extract_json_from_markdown(labware_info)
+
+        steps_data = json.loads(steps_info_clean)
+        labware_data = json.loads(labware_info_clean)
+
+        # 统一处理所有数据
+        protocol_graph = build_protocol_graph(labware_data, steps_data, workstation_name=workstation_name)
+
+        # 检测协议类型（用于标签）
+        protocol_type = "bio" if any("biomek" in step.get("template", "") for step in refactored_steps) else "organic"
+
+        # 转换为工作流格式
+        data = protocol_graph.to_dict()
+
+        # 转换节点格式
+        for i, node in enumerate(data["nodes"]):
+            description = node.get("description", "")
+            onode = {
+                "template": node.pop("template"),
+                "id": node["id"],
+                "lab_node_type": node.get("lab_node_type", "Device"),
+                "name": description or f"Node {i + 1}",
+                "params": {"default": node},
+                "handles": {},
+            }
+
+            # 处理边连接
+            for edge in data["links"]:
+                if edge["source"] == node["id"]:
+                    source_port = edge.get("source_port", "output")
+                    if source_port not in onode["handles"]:
+                        onode["handles"][source_port] = {"type": "source"}
+
+                if edge["target"] == node["id"]:
+                    target_port = edge.get("target_port", "input")
+                    if target_port not in onode["handles"]:
+                        onode["handles"][target_port] = {"type": "target"}
+
+            data["nodes"][i] = onode
+
+        # 发送到API创建工作流
+        api_secret = configs.Lab.Key
+        if not api_secret:
+            return {"error": "API SecretKey is not configured", "success": False}
+
+        # Step 1: 创建工作流
+        workflow_url = f"{configs.Lab.Api}/api/v1/workflow/"
+        headers = {
+            "Content-Type": "application/json",
+        }
+        params = {"secret_key": api_secret}
+
+        graph_data = {"name": workflow_name, **data}
+
+        logger.info(f"Creating workflow: {workflow_name}")
+        response = requests.post(
+            workflow_url, params=params, json=graph_data, headers=headers, timeout=configs.Lab.Timeout
+        )
+        response.raise_for_status()
+
+        workflow_info = response.json()
+
+        if workflow_info.get("code") != 0:
+            error_msg = f"API returned an error: {workflow_info.get('msg', 'Unknown Error')}"
+            logger.error(error_msg)
+            return {"error": error_msg, "success": False}
+
+        workflow_uuid = workflow_info.get("data", {}).get("uuid")
+        if not workflow_uuid:
+            return {"error": "Failed to get workflow UUID from response", "success": False}
+
+        # Step 2: 添加到模板库（可选）
+        try:
+            library_url = f"{configs.Lab.Api}/api/flociety/vs/workflows/library/"
+            lib_payload = {
+                "workflow_uuid": workflow_uuid,
+                "title": workflow_name,
+                "description": workflow_description,
+                "labels": [protocol_type.title(), "Auto-generated"],
+            }
+
+            library_response = requests.post(
+                library_url, params=params, json=lib_payload, headers=headers, timeout=configs.Lab.Timeout
+            )
+            library_response.raise_for_status()
+
+            library_info = library_response.json()
+            logger.info(f"Workflow added to library: {library_info}")
+
+            return {
+                "success": True,
+                "workflow_uuid": workflow_uuid,
+                "workflow_info": workflow_info.get("data"),
+                "library_info": library_info.get("data"),
+                "protocol_type": protocol_type,
+                "message": f"Workflow '{workflow_name}' created successfully",
+            }
+
+        except Exception as e:
+            # 即使添加到库失败，工作流创建仍然成功
+            logger.warning(f"Failed to add workflow to library: {str(e)}")
+            return {
+                "success": True,
+                "workflow_uuid": workflow_uuid,
+                "workflow_info": workflow_info.get("data"),
+                "protocol_type": protocol_type,
+                "message": f"Workflow '{workflow_name}' created successfully (library addition failed)",
+            }
+
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Network error when calling API: {str(e)}"
+        logger.error(error_msg)
+        return {"error": error_msg, "success": False}
+    except json.JSONDecodeError as e:
+        error_msg = f"JSON parsing error: {str(e)}"
+        logger.error(error_msg)
+        return {"error": error_msg, "success": False}
+    except Exception as e:
+        error_msg = f"An unexpected error occurred: {str(e)}"
+        logger.error(error_msg)
+        logger.error(traceback.format_exc())
+        return {"error": error_msg, "success": False}

test/experiments/comprehensive_protocol/comprehensive_station.json

@@ -170,15 +170,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 1000.0
+                "max_volume": 1000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 200,
+                "size_y": 150,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                    {
-                        "liquid_type": "DMF",
-                        "liquid_volume": 1000.0
-                    }
-                ]
+                "liquids": [["DMF", 500.0]],
+                "pending_liquids": [["DMF", 500.0]]
             }
         },
         {
@@ -194,15 +195,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 1000.0
+                "max_volume": 1000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 200,
+                "size_y": 150,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                    {
-                        "liquid_type": "ethyl_acetate",
-                        "liquid_volume": 1000.0
-                    }
-                ]
+                "liquids": [["ethyl_acetate", 1000.0]],
+                "pending_liquids": [["ethyl_acetate", 1000.0]]
             }
         },
         {
@@ -218,15 +220,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 1000.0
+                "max_volume": 1000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 300,
+                "size_y": 150,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                    {
-                        "liquid_type": "hexane",
-                        "liquid_volume": 1000.0
-                    }
-                ]
+                "liquids": [["hexane", 1000.0]],
+                "pending_liquids": [["hexane", 1000.0]]
             }
         },
         {
@@ -242,15 +245,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 1000.0
+                "max_volume": 1000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 900,
+                "size_y": 150,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                    {
-                        "liquid_type": "methanol",
-                        "liquid_volume": 1000.0
-                    }
-                ]
+                "liquids": [["methanol", 1000.0]],
+                "pending_liquids": [["methanol", 1000.0]]
             }
         },
         {
@@ -266,15 +270,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 1000.0
+                "max_volume": 1000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 950,
+                "size_y": 150,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                    {
-                        "liquid_type": "water",
-                        "liquid_volume": 1000.0
-                    }
-                ]
+                "liquids": [["water", 1000.0]],
+                "pending_liquids": [["water", 1000.0]]
             }
         },
         {
@@ -335,14 +340,16 @@
             },
             "config": {
                 "max_volume": 500.0,
+                "type": "RegularContainer",
+                "category": "container",
                 "max_temp": 200.0,
                 "min_temp": -20.0,
                 "has_stirrer": true,
                 "has_heater": true
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -419,11 +426,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 2000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 500,
+                "size_y": 400,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -439,11 +451,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 2000.0
+                "max_volume": 2000.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 1100,
+                "size_y": 500,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -649,11 +666,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 250.0
+                "max_volume": 250.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 900,
+                "size_y": 500,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -669,11 +691,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 250.0
+                "max_volume": 250.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 950,
+                "size_y": 500,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -689,11 +716,16 @@
                 "z": 0
             },
             "config": {
-                "max_volume": 250.0
+                "max_volume": 250.0,
+                "type": "RegularContainer",
+                "category": "container",
+                "size_x": 1050,
+                "size_y": 500,
+                "size_z": 0
             },
             "data": {
-                "liquids": [
-                ]
+                "liquids": [],
+                "pending_liquids": []
             }
         },
         {
@@ -733,6 +765,11 @@
             },
             "config": {
                 "max_volume": 500.0,
+                "size_x": 550,
+                "size_y": 250,
+                "size_z": 0,
+                "type": "RegularContainer",
+                "category": "container",
                 "reagent": "sodium_chloride",
                 "physical_state": "solid"
             },
@@ -756,6 +793,11 @@
             },
             "config": {
                 "volume": 500.0,
+                "size_x": 600,
+                "size_y": 250,
+                "size_z": 0,
+                "type": "RegularContainer",
+                "category": "container",
                 "reagent": "sodium_carbonate",
                 "physical_state": "solid"
             },
@@ -779,6 +821,11 @@
             },
             "config": {
                 "volume": 500.0,
+                "size_x": 650,
+                "size_y": 250,
+                "size_z": 0,
+                "type": "RegularContainer",
+                "category": "container",
                 "reagent": "magnesium_chloride",
                 "physical_state": "solid"
             },

test/experiments/dispensing_station_bioyond.json

@@ -8,7 +8,7 @@
             ],
             "parent": null,
             "type": "device",
-            "class": "dispensing_station.bioyond",
+            "class": "bioyond_dispensing_station",
             "config": {
                 "config": {
                     "api_key": "DE9BDDA0",
@@ -20,13 +20,6 @@
                         "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerPreparationStation_Deck"
                     }
                 },
-                "station_config": {
-                    "station_type": "dispensing_station",
-                    "enable_dispensing_station": true,
-                    "enable_reaction_station": false,
-                    "station_name": "DispensingStation_001",
-                    "description": "Bioyond配液工作站"
-                },
                 "protocol_type": []
             },
             "data": {}
@@ -57,4 +50,4 @@
             "data": {}
         }
     ]
-}
+}

test/experiments/reaction_station_bioyond.json

@@ -10,7 +10,7 @@
             "type": "device",
             "class": "reaction_station.bioyond",
             "config": {
-                "bioyond_config": {
+                "config": {
                     "api_key": "DE9BDDA0",
                     "api_host": "http://192.168.1.200:44402",
                     "workflow_mappings": {
@@ -19,14 +19,18 @@
                         "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
                         "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
                         "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding(titration)": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
+                        "Liquid_feeding(titration)": "3a16082a-96ac-0449-446a-4ed39f3365b6",
+                        "liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
                         "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
                     },
                     "material_type_mappings": {
-                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
+                        "烧杯": ["YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"],
+                        "试剂瓶": ["YB_1BottleCarrier", ""],
+                        "样品板": ["YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"],
+                        "分装板": ["YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"],
+                        "样品瓶": ["YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"],
+                        "90%分装小瓶": ["YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"],
+                        "10%分装小瓶": ["YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"]
                     }
                 },
                 "deck": {
@@ -42,7 +46,6 @@
         {
             "id": "Bioyond_Deck",
             "name": "Bioyond_Deck",
-            "sample_id": null,
             "children": [
             ],
             "parent": "reaction_station_bioyond",

test/experiments/reaction_station_bioyond_test.json

@@ -24,9 +24,9 @@
                         "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
                     },
                     "material_type_mappings": {
-                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
+                        "烧杯": "YB_1FlaskCarrier",
+                        "试剂瓶": "YB_1BottleCarrier",
+                        "样品板": "YB_6VialCarrier"
                     }
                 },
                 "deck": {

test/registry/example_devices.py

@@ -3,7 +3,8 @@
 """
 
 import asyncio
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, List
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class SmartPumpController:
@@ -14,6 +15,8 @@ class SmartPumpController:
     适用于实验室自动化系统中的液体处理任务。
     """
 
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, device_id: str = "smart_pump_01", port: str = "/dev/ttyUSB0"):
         """
         初始化智能泵控制器
@@ -30,6 +33,9 @@ class SmartPumpController:
         self.calibration_factor = 1.0
         self.pump_mode = "continuous"  # continuous, volume, rate
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     def connect_device(self, timeout: int = 10) -> bool:
         """
         连接到泵设备
@@ -90,7 +96,7 @@ class SmartPumpController:
         pump_time = (volume / flow_rate) * 60  # 转换为秒
 
         self.current_flow_rate = flow_rate
-        await asyncio.sleep(min(pump_time, 3.0))  # 模拟泵送过程
+        await self._ros_node.sleep(min(pump_time, 3.0))  # 模拟泵送过程
 
         self.total_volume_pumped += volume
         self.current_flow_rate = 0.0
@@ -170,6 +176,8 @@ class AdvancedTemperatureController:
     适用于需要精确温度控制的化学反应和材料处理过程。
     """
 
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, controller_id: str = "temp_controller_01"):
         """
         初始化温度控制器
@@ -185,6 +193,9 @@ class AdvancedTemperatureController:
         self.pid_enabled = True
         self.temperature_history: List[Dict] = []
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     def set_target_temperature(self, temperature: float, rate: float = 10.0) -> bool:
         """
         设置目标温度
@@ -238,7 +249,7 @@ class AdvancedTemperatureController:
                 }
             )
 
-            await asyncio.sleep(step_time)
+            await self._ros_node.sleep(step_time)
 
             # 保持历史记录不超过100条
             if len(self.temperature_history) > 100:
@@ -330,6 +341,8 @@ class MultiChannelAnalyzer:
     常用于光谱分析、电化学测量等应用场景。
     """
 
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, analyzer_id: str = "analyzer_01", channels: int = 8):
         """
         初始化多通道分析仪
@@ -344,6 +357,9 @@ class MultiChannelAnalyzer:
         self.is_measuring = False
         self.sample_rate = 1000  # Hz
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     def configure_channel(self, channel: int, enabled: bool = True, unit: str = "V") -> bool:
         """
         配置通道
@@ -376,7 +392,7 @@ class MultiChannelAnalyzer:
 
         # 模拟数据采集
         measurements = []
-        for second in range(duration):
+        for _ in range(duration):
             timestamp = asyncio.get_event_loop().time()
             frame_data = {}
 
@@ -391,7 +407,7 @@ class MultiChannelAnalyzer:
 
             measurements.append({"timestamp": timestamp, "data": frame_data})
 
-            await asyncio.sleep(1.0)  # 每秒采集一次
+            await self._ros_node.sleep(1.0)  # 每秒采集一次
 
         self.is_measuring = False
 
@@ -465,6 +481,8 @@ class AutomatedDispenser:
     集成称重功能，确保分配精度和重现性。
     """
 
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, dispenser_id: str = "dispenser_01"):
         """
         初始化自动分配器
@@ -479,6 +497,9 @@ class AutomatedDispenser:
         self.container_capacity = 1000.0  # mL
         self.precision_mode = True
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     def move_to_position(self, x: float, y: float, z: float) -> bool:
         """
         移动到指定位置
@@ -517,7 +538,7 @@ class AutomatedDispenser:
         if viscosity == "high":
             dispense_time *= 2  # 高粘度液体需要更长时间
 
-        await asyncio.sleep(min(dispense_time, 5.0))  # 最多等待5秒
+        await self._ros_node.sleep(min(dispense_time, 5.0))  # 最多等待5秒
 
         self.dispensed_total += volume
 

test/resources/YB_materials_info.json

@@ -0,0 +1,52 @@
+[
+    {
+        "id": "3a1d377b-299d-d0f2-ced9-48257f60dfad",
+        "typeName": "加样头(大)",
+        "code": "0005-00145",
+        "barCode": "",
+        "name": "LiDFOB",
+        "quantity": 9999.0,
+        "lockQuantity": 0.0,
+        "unit": "个",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+                "whid": "3a19da56-1378-613b-29f2-871e1a287aa5",
+                "whName": "粉末加样头堆栈",
+                "code": "0005-0001",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": []
+    },
+    {
+        "id": "3a1d377b-6a81-6a7e-147c-f89f6463656d",
+        "typeName": "液",
+        "code": "0006-00141",
+        "barCode": "",
+        "name": "EMC",
+        "quantity": 99999.0,
+        "lockQuantity": 0.0,
+        "unit": "g",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a1baa20-a7b1-c665-8b9c-d8099d07d2f6",
+                "whid": "3a1baa20-a7b0-5c19-8844-5de8924d4e78",
+                "whName": "4号手套箱内部堆栈",
+                "code": "0015-0001",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": []
+    }
+]

test/resources/test copy.json

@@ -0,0 +1,99 @@
+ {
+        "typeId": "3a190c8b-3284-af78-d29f-9a69463ad047",
+        "code": "",
+        "barCode": "",
+        "name": "test",
+        "unit": "",
+        "parameters": "{}",
+        "quantity": "",
+        "details": [
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)11",
+                "quantity": "1",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)21",
+                "quantity": "1",
+                "x": 2,
+                "y": 1,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)12",
+                "quantity": "1",
+                "x": 1,
+                "y": 2,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)22",
+                "quantity": "1",
+                "x": 2,
+                "y": 2,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)13",
+                "quantity": "1",
+                "x": 1,
+                "y": 3,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)23",
+                "quantity": "1",
+                "x": 2,
+                "y": 3,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)14",
+                "quantity": "1",
+                "x": 1,
+                "y": 4,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            },
+            {
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
+                "code": "",
+                "name": "配液瓶(小)24",
+                "quantity": "1",
+                "x": 2,
+                "y": 4,
+                "z": 1,
+                "unit": "",
+                "parameters": "{}"
+            }
+        ]
+    }

test/resources/test.json

@@ -0,0 +1,148 @@
+[
+    {
+        "id": "3a1d4c14-a9fb-d7dc-9e96-7a3ad6e50219",
+        "typeName": "配液瓶(小)板",
+        "code": "0001-00093",
+        "barCode": "",
+        "name": "test",
+        "quantity": 2.0,
+        "lockQuantity": 0.0,
+        "unit": "块",
+        "status": 1,
+        "isUse": false,
+        "locations": [
+            {
+                "id": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
+                "whid": "3a19deae-2c79-05a3-9c76-8e6760424841",
+                "whName": "手动堆栈",
+                "code": "1",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "quantity": 0
+            }
+        ],
+        "detail": [
+            {
+                "id": "3a1d4c14-a9fc-1daa-71fa-146cb1ccb930",
+                "detailMaterialId": "3a1d4c14-a9fc-4f38-4c48-68486c391c42",
+                "code": "0001-00093 - 05",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 3,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-3659-ea61-cd587da9e131",
+                "detailMaterialId": "3a1d4c14-a9fc-018f-93e5-c49343d37758",
+                "code": "0001-00093 - 08",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 4,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-3f94-de83-979d2646e313",
+                "detailMaterialId": "3a1d4c14-a9fc-9987-c0ef-4b7cbad49e6b",
+                "code": "0001-00093 - 01",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 1,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-8c35-6b25-913b11dbaf4e",
+                "detailMaterialId": "3a1d4c14-a9fc-9a83-865b-0c26ea5e8cc4",
+                "code": "0001-00093 - 03",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 2,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-b41f-e968-64953bfddccd",
+                "detailMaterialId": "3a1d4c14-a9fc-daf7-9d64-e5ec8d3ae0e2",
+                "code": "0001-00093 - 07",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 1,
+                "y": 4,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-c20f-c26e-b1bb2cdc3bca",
+                "detailMaterialId": "3a1d4c14-a9fc-673b-ac83-aaaf71287f1f",
+                "code": "0001-00093 - 06",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 3,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-cf21-059c-fde361d82b6f",
+                "detailMaterialId": "3a1d4c14-a9fc-25b1-e736-6b0d8dac0fae",
+                "code": "0001-00093 - 02",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 1,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            },
+            {
+                "id": "3a1d4c14-a9fc-d732-2b93-9b2bd2bf581b",
+                "detailMaterialId": "3a1d4c14-a9fc-7f5d-b6b6-8bcb2e15f320",
+                "code": "0001-00093 - 04",
+                "name": "配液瓶(小)",
+                "quantity": "1",
+                "lockQuantity": "0",
+                "unit": "个",
+                "x": 2,
+                "y": 2,
+                "z": 1,
+                "associateId": null,
+                "typeName": "配液瓶(小)",
+                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
+            }
+        ]
+    }
+]

test/resources/test_bottle_carrier.py

@@ -1,7 +1,7 @@
 import pytest
 
 from unilabos.resources.bioyond.bottle_carriers import BIOYOND_Electrolyte_6VialCarrier, BIOYOND_Electrolyte_1BottleCarrier
-from unilabos.resources.bioyond.bottles import BIOYOND_PolymerStation_Solid_Vial, BIOYOND_PolymerStation_Solution_Beaker, BIOYOND_PolymerStation_Reagent_Bottle
+from unilabos.resources.bioyond.bottles import YB_Solid_Vial, YB_Solution_Beaker, YB_Reagent_Bottle
 
 
 def test_bottle_carrier() -> "BottleCarrier":
@@ -16,9 +16,9 @@ def test_bottle_carrier() -> "BottleCarrier":
     print(f"1烧杯载架: {beaker_carrier.name}, 位置数: {len(beaker_carrier.sites)}")
 
     # 创建瓶子和烧杯
-    powder_bottle = BIOYOND_PolymerStation_Solid_Vial("powder_bottle_01")
-    solution_beaker = BIOYOND_PolymerStation_Solution_Beaker("solution_beaker_01")
-    reagent_bottle = BIOYOND_PolymerStation_Reagent_Bottle("reagent_bottle_01")
+    powder_bottle = YB_Solid_Vial("powder_bottle_01")
+    solution_beaker = YB_Solution_Beaker("solution_beaker_01")
+    reagent_bottle = YB_Reagent_Bottle("reagent_bottle_01")
 
     print(f"\n创建的物料:")
     print(f"粉末瓶: {powder_bottle.name} - {powder_bottle.diameter}mm x {powder_bottle.height}mm, {powder_bottle.max_volume}μL")

test/resources/test_converter_bioyond.py

@@ -12,23 +12,13 @@ lab_registry.setup()
 
 
 type_mapping = {
-    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-    "样品板": "BIOYOND_PolymerStation_6StockCarrier",
-    "分装板": "BIOYOND_PolymerStation_6VialCarrier",
-    "样品瓶": "BIOYOND_PolymerStation_Solid_Stock",
-    "90%分装小瓶": "BIOYOND_PolymerStation_Solid_Vial",
-    "10%分装小瓶": "BIOYOND_PolymerStation_Liquid_Vial",
-}
-
-type_uuid_mapping = {
-    "烧杯": "",
-    "试剂瓶": "",
-    "样品板": "",
-    "分装板": "3a14196e-5dfe-6e21-0c79-fe2036d052c4",
-    "样品瓶": "3a14196a-cf7d-8aea-48d8-b9662c7dba94",
-    "90%分装小瓶": "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea",
-    "10%分装小瓶": "3a14196c-76be-2279-4e22-7310d69aed68",
+    "烧杯": ("YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
+    "试剂瓶": ("YB_1BottleCarrier", ""),
+    "样品板": ("YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
+    "分装板": ("YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
+    "样品瓶": ("YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
+    "90%分装小瓶": ("YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
+    "10%分装小瓶": ("YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
 }
 
 

test/resources/test_itemized_carrier.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+测试修改后的 get_child_identifier 函数
+"""
+
+from unilabos.resources.itemized_carrier import ItemizedCarrier, Bottle
+from pylabrobot.resources.coordinate import Coordinate
+
+def test_get_child_identifier_with_indices():
+    """测试返回x,y,z索引的 get_child_identifier 函数"""
+    
+    # 创建一些测试瓶子
+    bottle1 = Bottle("bottle1", diameter=25.0, height=50.0, max_volume=15.0)
+    bottle1.location = Coordinate(10, 20, 5)
+    
+    bottle2 = Bottle("bottle2", diameter=25.0, height=50.0, max_volume=15.0) 
+    bottle2.location = Coordinate(50, 20, 5)
+    
+    bottle3 = Bottle("bottle3", diameter=25.0, height=50.0, max_volume=15.0) 
+    bottle3.location = Coordinate(90, 20, 5)
+    
+    # 创建载架，指定维度
+    sites = {
+        "A1": bottle1,
+        "A2": bottle2, 
+        "A3": bottle3,
+        "B1": None,  # 空位
+        "B2": None,
+        "B3": None
+    }
+    
+    carrier = ItemizedCarrier(
+        name="test_carrier",
+        size_x=150,
+        size_y=100,
+        size_z=30,
+        num_items_x=3,  # 3列
+        num_items_y=2,  # 2行  
+        num_items_z=1,  # 1层
+        sites=sites
+    )
+    
+    print("测试载架维度:")
+    print(f"num_items_x: {carrier.num_items_x}")
+    print(f"num_items_y: {carrier.num_items_y}")
+    print(f"num_items_z: {carrier.num_items_z}")
+    print()
+    
+    # 测试获取bottle1的标识符信息 (A1 = idx:0, x:0, y:0, z:0)
+    result1 = carrier.get_child_identifier(bottle1)
+    print("测试bottle1 (A1):")
+    print(f"  identifier: {result1['identifier']}")
+    print(f"  idx: {result1['idx']}")
+    print(f"  x index: {result1['x']}")
+    print(f"  y index: {result1['y']}")
+    print(f"  z index: {result1['z']}")
+    
+    # Assert 验证 bottle1 (A1) 的结果
+    assert result1['identifier'] == 'A1', f"Expected identifier 'A1', got '{result1['identifier']}'"
+    assert result1['idx'] == 0, f"Expected idx 0, got {result1['idx']}"
+    assert result1['x'] == 0, f"Expected x index 0, got {result1['x']}"
+    assert result1['y'] == 0, f"Expected y index 0, got {result1['y']}"
+    assert result1['z'] == 0, f"Expected z index 0, got {result1['z']}"
+    print("  ✓ bottle1 (A1) 测试通过")
+    print()
+    
+    # 测试获取bottle2的标识符信息 (A2 = idx:1, x:1, y:0, z:0)
+    result2 = carrier.get_child_identifier(bottle2)
+    print("测试bottle2 (A2):")
+    print(f"  identifier: {result2['identifier']}")
+    print(f"  idx: {result2['idx']}")
+    print(f"  x index: {result2['x']}")
+    print(f"  y index: {result2['y']}")
+    print(f"  z index: {result2['z']}")
+    
+    # Assert 验证 bottle2 (A2) 的结果
+    assert result2['identifier'] == 'A2', f"Expected identifier 'A2', got '{result2['identifier']}'"
+    assert result2['idx'] == 1, f"Expected idx 1, got {result2['idx']}"
+    assert result2['x'] == 1, f"Expected x index 1, got {result2['x']}"
+    assert result2['y'] == 0, f"Expected y index 0, got {result2['y']}"
+    assert result2['z'] == 0, f"Expected z index 0, got {result2['z']}"
+    print("  ✓ bottle2 (A2) 测试通过")
+    print()
+        
+    # 测试获取bottle3的标识符信息 (A3 = idx:2, x:2, y:0, z:0)
+    result3 = carrier.get_child_identifier(bottle3)
+    print("测试bottle3 (A3):")
+    print(f"  identifier: {result3['identifier']}")
+    print(f"  idx: {result3['idx']}")
+    print(f"  x index: {result3['x']}")
+    print(f"  y index: {result3['y']}")
+    print(f"  z index: {result3['z']}")
+    
+    # Assert 验证 bottle3 (A3) 的结果
+    assert result3['identifier'] == 'A3', f"Expected identifier 'A3', got '{result3['identifier']}'"
+    assert result3['idx'] == 2, f"Expected idx 2, got {result3['idx']}"
+    assert result3['x'] == 2, f"Expected x index 2, got {result3['x']}"
+    assert result3['y'] == 0, f"Expected y index 0, got {result3['y']}"
+    assert result3['z'] == 0, f"Expected z index 0, got {result3['z']}"
+    print("  ✓ bottle3 (A3) 测试通过")
+    print()
+    
+    # 测试错误情况：查找不存在的资源
+    bottle_not_exists = Bottle("bottle_not_exists", diameter=25.0, height=50.0, max_volume=15.0)
+    try:
+        carrier.get_child_identifier(bottle_not_exists)
+        assert False, "应该抛出 ValueError 异常"
+    except ValueError as e:
+        print("✓ 正确抛出了 ValueError 异常：", str(e))
+        assert "is not assigned to this carrier" in str(e), "异常消息应该包含预期的文本"
+    
+    print("\n🎉 所有测试都通过了！")
+
+if __name__ == "__main__":
+    test_get_child_identifier_with_indices()

test/resources/test_resourcetreeset.py

@@ -0,0 +1,75 @@
+from ast import If
+import pytest
+import json
+import os
+
+from pylabrobot.resources import Resource as ResourcePLR
+from unilabos.resources.graphio import resource_bioyond_to_plr
+from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
+from unilabos.registry.registry import lab_registry
+
+from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
+from unilabos.resources.bioyond.decks import YB_Deck
+
+lab_registry.setup()
+
+
+type_mapping = {
+    "加样头(大)": ("YB_jia_yang_tou_da", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    "液": ("YB_1BottleCarrier", "3a190ca1-2add-2b23-f8e1-bbd348b7f790"),
+    "配液瓶(小)板": ("YB_peiyepingxiaoban", "3a190c8b-3284-af78-d29f-9a69463ad047"),
+    "配液瓶(小)": ("YB_pei_ye_xiao_Bottler", "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"),
+}
+
+
+@pytest.fixture
+def bioyond_materials_reaction() -> list[dict]:
+    print("加载 BioYond 物料数据...")
+    print(os.getcwd())
+    with open("bioyond_materials_reaction.json", "r", encoding="utf-8") as f:
+        data = json.load(f)
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+@pytest.fixture
+def bioyond_materials_liquidhandling_1() -> list[dict]:
+    print("加载 BioYond 物料数据...")
+    print(os.getcwd())
+    with open("bioyond_materials_liquidhandling_1.json", "r", encoding="utf-8") as f:
+        data = json.load(f)
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+@pytest.fixture
+def bioyond_materials_liquidhandling_2() -> list[dict]:
+    print("加载 BioYond 物料数据...")
+    print(os.getcwd())
+    with open("bioyond_materials_liquidhandling_2.json", "r", encoding="utf-8") as f:
+        data = json.load(f)
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+@pytest.mark.parametrize("materials_fixture", [
+    "bioyond_materials_reaction",
+    "bioyond_materials_liquidhandling_1",
+])
+def test_resourcetreeset_from_plr() -> list[dict]:
+    # 直接加载 bioyond_materials_reaction.json 文件
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    json_path = os.path.join(current_dir, "test.json")
+    with open(json_path, "r", encoding="utf-8") as f:
+        materials = json.load(f)
+    deck = YB_Deck("test_deck")
+    output = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=deck)
+    print(output)
+    # print(deck.summary())
+
+    r = ResourceTreeSet.from_plr_resources([deck])
+    print(r.dump())
+    # json.dump(deck.serialize(), open("test.json", "w", encoding="utf-8"), indent=4)
+
+if __name__ == "__main__":
+    test_resourcetreeset_from_plr()

test/workflow/example_bio.json

@@ -0,0 +1,186 @@
+{
+  "workflow": [
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_1",
+        "targets": "Liquid_2",
+        "asp_vol": 66.0,
+        "dis_vol": 66.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_2",
+        "targets": "Liquid_3",
+        "asp_vol": 58.0,
+        "dis_vol": 96.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_4",
+        "targets": "Liquid_2",
+        "asp_vol": 85.0,
+        "dis_vol": 170.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_4",
+        "targets": "Liquid_2",
+        "asp_vol": 63.333333333333336,
+        "dis_vol": 170.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_2",
+        "targets": "Liquid_3",
+        "asp_vol": 72.0,
+        "dis_vol": 150.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_4",
+        "targets": "Liquid_2",
+        "asp_vol": 85.0,
+        "dis_vol": 170.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_4",
+        "targets": "Liquid_2",
+        "asp_vol": 63.333333333333336,
+        "dis_vol": 170.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_2",
+        "targets": "Liquid_3",
+        "asp_vol": 72.0,
+        "dis_vol": 150.0,
+        "asp_flow_rate": 94.0,
+        "dis_flow_rate": 94.0
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_2",
+        "targets": "Liquid_3",
+        "asp_vol": 20.0,
+        "dis_vol": 20.0,
+        "asp_flow_rate": 7.6,
+        "dis_flow_rate": 7.6
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_5",
+        "targets": "Liquid_2",
+        "asp_vol": 6.0,
+        "dis_vol": 12.0,
+        "asp_flow_rate": 7.6,
+        "dis_flow_rate": 7.6
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_5",
+        "targets": "Liquid_2",
+        "asp_vol": 10.666666666666666,
+        "dis_vol": 12.0,
+        "asp_flow_rate": 7.599999999999999,
+        "dis_flow_rate": 7.6
+      }
+    },
+    {
+      "action": "transfer_liquid",
+      "action_args": {
+        "sources": "Liquid_2",
+        "targets": "Liquid_6",
+        "asp_vol": 12.0,
+        "dis_vol": 10.0,
+        "asp_flow_rate": 7.6,
+        "dis_flow_rate": 7.6
+      }
+    }
+  ],
+  "reagent": {
+    "Liquid_6": {
+      "slot": 1,
+      "well": [
+        "A2"
+      ],
+      "labware": "elution plate"
+    },
+    "Liquid_1": {
+      "slot": 2,
+      "well": [
+        "A1",
+        "A2",
+        "A4"
+      ],
+      "labware": "reagent reservoir"
+    },
+    "Liquid_4": {
+      "slot": 2,
+      "well": [
+        "A1",
+        "A2",
+        "A4"
+      ],
+      "labware": "reagent reservoir"
+    },
+    "Liquid_5": {
+      "slot": 2,
+      "well": [
+        "A1",
+        "A2",
+        "A4"
+      ],
+      "labware": "reagent reservoir"
+    },
+    "Liquid_2": {
+      "slot": 4,
+      "well": [
+        "A2"
+      ],
+      "labware": "TAG1 plate on Magnetic Module GEN2"
+    },
+    "Liquid_3": {
+      "slot": 12,
+      "well": [
+        "A1"
+      ],
+      "labware": "Opentrons Fixed Trash"
+    }
+  }
+}

test/workflow/example_prcxi.json

@@ -0,0 +1,63 @@
+{
+    "steps_info": [
+        {
+            "step_number": 1,
+            "action": "transfer_liquid",
+            "parameters": {
+                "source": "sample supernatant",
+                "target": "antibody-coated well",
+                "volume": 100
+            }
+        },
+        {
+            "step_number": 2,
+            "action": "transfer_liquid",
+            "parameters": {
+                "source": "washing buffer",
+                "target": "antibody-coated well",
+                "volume": 200
+            }
+        },
+        {
+            "step_number": 3,
+            "action": "transfer_liquid",
+            "parameters": {
+                "source": "washing buffer",
+                "target": "antibody-coated well",
+                "volume": 200
+            }
+        },
+        {
+            "step_number": 4,
+            "action": "transfer_liquid",
+            "parameters": {
+                "source": "washing buffer",
+                "target": "antibody-coated well",
+                "volume": 200
+            }
+        },
+        {
+            "step_number": 5,
+            "action": "transfer_liquid",
+            "parameters": {
+                "source": "TMB substrate",
+                "target": "antibody-coated well",
+                "volume": 100
+            }
+        }
+    ],
+    "labware_info": [
+        {"reagent_name": "sample supernatant", "material_name": "96深孔板", "positions": 1},
+        {"reagent_name": "washing buffer", "material_name": "储液槽", "positions": 2},
+        {"reagent_name": "TMB substrate", "material_name": "储液槽", "positions": 3},
+        {"reagent_name": "antibody-coated well", "material_name": "96 细胞培养皿", "positions": 4},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 5},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 6},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 7},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 8},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 9},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 10},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 11},
+        {"reagent_name": "", "material_name": "300μL Tip头", "positions": 13}
+    ]
+}

test/workflow/merge_workflow.py

@@ -0,0 +1,94 @@
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+import pytest
+
+from scripts.workflow import build_protocol_graph, draw_protocol_graph, draw_protocol_graph_with_ports
+
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+
+def _normalize_steps(data):
+    normalized = []
+    for step in data:
+        action = step.get("action") or step.get("operation")
+        if not action:
+            continue
+        raw_params = step.get("parameters") or step.get("action_args") or {}
+        params = dict(raw_params)
+
+        if "source" in raw_params and "sources" not in raw_params:
+            params["sources"] = raw_params["source"]
+        if "target" in raw_params and "targets" not in raw_params:
+            params["targets"] = raw_params["target"]
+
+        description = step.get("description") or step.get("purpose")
+        step_dict = {"action": action, "parameters": params}
+        if description:
+            step_dict["description"] = description
+        normalized.append(step_dict)
+    return normalized
+
+
+def _normalize_labware(data):
+    labware = {}
+    for item in data:
+        reagent_name = item.get("reagent_name")
+        key = reagent_name or item.get("material_name") or item.get("name")
+        if not key:
+            continue
+        key = str(key)
+        idx = 1
+        original_key = key
+        while key in labware:
+            idx += 1
+            key = f"{original_key}_{idx}"
+
+        labware[key] = {
+            "slot": item.get("positions") or item.get("slot"),
+            "labware": item.get("material_name") or item.get("labware"),
+            "well": item.get("well", []),
+            "type": item.get("type", "reagent"),
+            "role": item.get("role", ""),
+            "name": key,
+        }
+    return labware
+
+
+@pytest.mark.parametrize("protocol_name", [
+    "example_bio",
+    # "bioyond_materials_liquidhandling_1",
+    "example_prcxi",
+])
+def test_build_protocol_graph(protocol_name):
+    data_path = Path(__file__).with_name(f"{protocol_name}.json")
+    with data_path.open("r", encoding="utf-8") as fp:
+        d = json.load(fp)
+
+    if "workflow" in d and "reagent" in d:
+        protocol_steps = d["workflow"]
+        labware_info = d["reagent"]
+    elif "steps_info" in d and "labware_info" in d:
+        protocol_steps = _normalize_steps(d["steps_info"])
+        labware_info = _normalize_labware(d["labware_info"])
+    else:
+        raise ValueError("Unsupported protocol format")
+
+    graph = build_protocol_graph(
+        labware_info=labware_info,
+        protocol_steps=protocol_steps,
+        workstation_name="PRCXi",
+    )
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M")
+    output_path = data_path.with_name(f"{protocol_name}_graph_{timestamp}.png")
+    draw_protocol_graph_with_ports(graph, str(output_path))
+    print(graph)

unilabos/app/backend.py

@@ -13,7 +13,7 @@ def start_backend(
     graph=None,
     controllers_config: dict = {},
     bridges=[],
-    without_host: bool = False,
+    is_slave: bool = False,
     visual: str = "None",
     resources_mesh_config: dict = {},
     **kwargs,
@@ -32,7 +32,7 @@ def start_backend(
         raise ValueError(f"Unsupported backend: {backend}")
 
     backend_thread = threading.Thread(
-        target=main if not without_host else slave,
+        target=main if not is_slave else slave,
         args=(
             devices_config,
             resources_config,

unilabos/app/main.py

@@ -11,18 +11,14 @@ from typing import Dict, Any, List
 import networkx as nx
 import yaml
 
-from unilabos.ros.nodes.resource_tracker import ResourceTreeSet, ResourceDict
-
 # 首先添加项目根目录到路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
 unilabos_dir = os.path.dirname(os.path.dirname(current_dir))
 if unilabos_dir not in sys.path:
     sys.path.append(unilabos_dir)
 
-from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 from unilabos.utils.banner_print import print_status, print_unilab_banner
-from unilabos.resources.graphio import modify_to_backend_format
-
+from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 
 def load_config_from_file(config_path):
     if config_path is None:
@@ -184,6 +180,7 @@ def main():
         working_dir = os.path.abspath(os.getcwd())
     else:
         working_dir = os.path.abspath(os.path.join(os.getcwd(), "unilabos_data"))
+
     if args_dict.get("working_dir"):
         working_dir = args_dict.get("working_dir", "")
         if config_path and not os.path.exists(config_path):
@@ -215,6 +212,14 @@ def main():
     # 加载配置文件
     print_status(f"当前工作目录为 {working_dir}", "info")
     load_config_from_file(config_path)
+
+    # 根据配置重新设置日志级别
+    from unilabos.utils.log import configure_logger, logger
+
+    if hasattr(BasicConfig, "log_level"):
+        logger.info(f"Log level set to '{BasicConfig.log_level}' from config file.")
+        configure_logger(loglevel=BasicConfig.log_level)
+
     if args_dict["addr"] == "test":
         print_status("使用测试环境地址", "info")
         HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
@@ -268,6 +273,8 @@ def main():
     from unilabos.app.web import http_client
     from unilabos.app.web import start_server
     from unilabos.app.register import register_devices_and_resources
+    from unilabos.resources.graphio import modify_to_backend_format
+    from unilabos.ros.nodes.resource_tracker import ResourceTreeSet, ResourceDict
 
     # 显示启动横幅
     print_unilab_banner(args_dict)
@@ -349,7 +356,7 @@ def main():
 
     if BasicConfig.upload_registry:
         # 设备注册到服务端 - 需要 ak 和 sk
-        if args_dict.get("ak") and args_dict.get("sk"):
+        if BasicConfig.ak and BasicConfig.sk:
             print_status("开始注册设备到服务端...", "info")
             try:
                 register_devices_and_resources(lab_registry)
@@ -368,22 +375,23 @@ def main():
 
     args_dict["bridges"] = []
 
-    # 获取通信客户端（仅支持WebSocket）
-    comm_client = get_communication_client()
-
-    if "websocket" in args_dict["app_bridges"]:
-        args_dict["bridges"].append(comm_client)
     if "fastapi" in args_dict["app_bridges"]:
         args_dict["bridges"].append(http_client)
-    if "websocket" in args_dict["app_bridges"]:
+    # 获取通信客户端（仅支持WebSocket）
+    if BasicConfig.is_host_mode:
+        comm_client = get_communication_client()
+        if "websocket" in args_dict["app_bridges"]:
+            args_dict["bridges"].append(comm_client)
+            def _exit(signum, frame):
+                comm_client.stop()
+                sys.exit(0)
 
-        def _exit(signum, frame):
-            comm_client.stop()
-            sys.exit(0)
+            signal.signal(signal.SIGINT, _exit)
+            signal.signal(signal.SIGTERM, _exit)
+            comm_client.start()
+    else:
+        print_status("SlaveMode跳过Websocket连接")
 
-        signal.signal(signal.SIGINT, _exit)
-        signal.signal(signal.SIGTERM, _exit)
-        comm_client.start()
     args_dict["resources_mesh_config"] = {}
     args_dict["resources_edge_config"] = resource_edge_info
     # web visiualize 2D

unilabos/app/register.py

@@ -1,11 +1,12 @@
 import json
 import time
+from typing import Optional, Tuple, Dict, Any
 
 from unilabos.utils.log import logger
 from unilabos.utils.type_check import TypeEncoder
 
 
-def register_devices_and_resources(lab_registry):
+def register_devices_and_resources(lab_registry, gather_only=False) -> Optional[Tuple[Dict[str, Any], Dict[str, Any]]]:
     """
     注册设备和资源到服务器（仅支持HTTP）
     """
@@ -28,6 +29,8 @@ def register_devices_and_resources(lab_registry):
         resources_to_register[resource_info["id"]] = resource_info
         logger.debug(f"[UniLab Register] 收集资源: {resource_info['id']}")
 
+    if gather_only:
+        return devices_to_register, resources_to_register
     # 注册设备
     if devices_to_register:
         try:

unilabos/app/web/client.py

@@ -6,6 +6,8 @@ HTTP客户端模块
 
 import json
 import os
+import time
+from threading import Thread
 from typing import List, Dict, Any, Optional
 
 import requests
@@ -73,6 +75,8 @@ class HTTPClient:
         Returns:
             Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
         """
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_add.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps({"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}, indent=4))
         # 从序列化数据中提取所有节点的UUID（保存旧UUID）
         old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
         if not self.initialized or first_add:
@@ -82,16 +86,18 @@ class HTTPClient:
                 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,
+                timeout=60,
             )
         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,
+                timeout=10,
             )
 
+        with open(os.path.join(BasicConfig.working_dir, "res_resource_tree_add.json"), "w", encoding="utf-8") as f:
+            f.write(f"{response.status_code}" + "\n" + response.text)
         # 处理响应，构建UUID映射
         uuid_mapping = {}
         if response.status_code == 200:
@@ -122,12 +128,16 @@ class HTTPClient:
         Returns:
             Dict[str, str]: 旧UUID到新UUID的映射关系 {old_uuid: new_uuid}
         """
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_tree_get.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps({"uuids": uuid_list, "with_children": with_children}, indent=4))
         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,
         )
+        with open(os.path.join(BasicConfig.working_dir, "res_resource_tree_get.json"), "w", encoding="utf-8") as f:
+            f.write(f"{response.status_code}" + "\n" + response.text)
         if response.status_code == 200:
             res = response.json()
             if "code" in res and res["code"] != 0:
@@ -183,12 +193,16 @@ class HTTPClient:
         Returns:
             Dict: 返回的资源数据
         """
+        with open(os.path.join(BasicConfig.working_dir, "req_resource_get.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps({"id": id, "with_children": with_children}, indent=4))
         response = requests.get(
             f"{self.remote_addr}/lab/material",
             params={"id": id, "with_children": with_children},
             headers={"Authorization": f"Lab {self.auth}"},
             timeout=20,
         )
+        with open(os.path.join(BasicConfig.working_dir, "res_resource_get.json"), "w", encoding="utf-8") as f:
+            f.write(f"{response.status_code}" + "\n" + response.text)
         return response.json()
 
     def resource_del(self, id: str) -> requests.Response:

unilabos/app/ws_client.py

@@ -421,7 +421,7 @@ class MessageProcessor:
                     ssl_context = ssl_module.create_default_context()
 
                 ws_logger = logging.getLogger("websockets.client")
-                ws_logger.setLevel(logging.INFO)
+                # 日志级别已在 unilabos.utils.log 中统一配置为 WARNING
 
                 async with websockets.connect(
                     self.websocket_url,
@@ -1197,7 +1197,7 @@ class WebSocketClient(BaseCommunicationClient):
             },
         }
         self.message_processor.send_message(message)
-        logger.debug(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
 
     def publish_job_status(
         self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None

unilabos/config/config.py

@@ -2,7 +2,7 @@ import base64
 import traceback
 import os
 import importlib.util
-from typing import Optional
+from typing import Optional, Literal
 from unilabos.utils import logger
 
 
@@ -18,6 +18,7 @@ class BasicConfig:
     vis_2d_enable = False
     enable_resource_load = True
     communication_protocol = "websocket"
+    log_level: Literal['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = "DEBUG"  # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
 
     @classmethod
     def auth_secret(cls):

unilabos/devices/cnc/grbl_async.py

@@ -12,6 +12,7 @@ from serial import Serial
 from serial.serialutil import SerialException
 
 from unilabos.messages import Point3D
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class GrblCNCConnectionError(Exception):
@@ -32,6 +33,7 @@ class GrblCNCInfo:
 class GrblCNCAsync:
     _status: str = "Offline"
     _position: Point3D = Point3D(x=0.0, y=0.0, z=0.0)
+    _ros_node: BaseROS2DeviceNode
     
     def __init__(self, port: str, address: str = "1", limits: tuple[int, int, int, int, int, int] = (-150, 150, -200, 0, 0, 60)):
         self.port = port
@@ -58,6 +60,9 @@ class GrblCNCAsync:
         self._run_future: Optional[Future[Any]] = None
         self._run_lock = Lock()
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     def _read_all(self):
         data = self._serial.read_until(b"\n")
         data_decoded = data.decode()
@@ -148,7 +153,7 @@ class GrblCNCAsync:
             try:
                 await self._query(command)
                 while True:
-                    await asyncio.sleep(0.2)  # Wait for 0.5 seconds before polling again
+                    await self._ros_node.sleep(0.2)  # Wait for 0.5 seconds before polling again
                     
                     status = await self.get_status()
                     if "Idle" in status:
@@ -214,7 +219,7 @@ class GrblCNCAsync:
             self._pose_number = i
             self.pose_number_remaining = len(points) - i
             await self.set_position(point)
-            await asyncio.sleep(0.5)
+            await self._ros_node.sleep(0.5)
         self._step_number = -1
 
     async def stop_operation(self):
@@ -235,7 +240,7 @@ class GrblCNCAsync:
     async def open(self):
         if self._read_task:
             raise GrblCNCConnectionError
-        self._read_task = asyncio.create_task(self._read_loop())
+        self._read_task = self._ros_node.create_task(self._read_loop())
 
         try:
             await self.get_status()

unilabos/devices/cnc/mock.py

@@ -2,6 +2,8 @@ import time
 import asyncio
 from pydantic import BaseModel
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class Point3D(BaseModel):
     x: float
@@ -14,9 +16,14 @@ def d(a: Point3D, b: Point3D) -> float:
 
 
 class MockCNCAsync:
+    _ros_node: BaseROS2DeviceNode["MockCNCAsync"]
+
     def __init__(self):
         self._position: Point3D = Point3D(x=0.0, y=0.0, z=0.0)
         self._status = "Idle"
+
+    def post_create(self, ros_node):
+        self._ros_node = ros_node
     
     @property
     def position(self) -> Point3D:
@@ -38,5 +45,5 @@ class MockCNCAsync:
             self._position.x = current_pos.x + (position.x - current_pos.x) / 20 * (i+1)
             self._position.y = current_pos.y + (position.y - current_pos.y) / 20 * (i+1)
             self._position.z = current_pos.z + (position.z - current_pos.z) / 20 * (i+1)
-            await asyncio.sleep(move_time / 20)
+            await self._ros_node.sleep(move_time / 20)
         self._status = "Idle"

unilabos/devices/electrolysis_water_platfrom/electrolysis_water_platfrom.py

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+import serial
+import time
+import csv
+import threading
+import os
+from collections import deque
+from typing import Dict, Any, Optional
+from pylabrobot.resources import Deck
+
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+
+
+class ElectrolysisWaterPlatform(WorkstationBase):
+    """
+    电解水平台工作站
+    基于 WorkstationBase 的电解水实验平台，支持串口通信和数据采集
+    """
+    
+    def __init__(
+        self, 
+        deck: Deck,
+        port: str = "COM10",
+        baudrate: int = 115200,
+        csv_path: Optional[str] = None,
+        timeout: float = 0.2,
+        **kwargs
+    ):
+        super().__init__(deck, **kwargs)
+        
+        # ========== 配置 ==========
+        self.port = port
+        self.baudrate = baudrate
+        # 如果没有指定路径，默认保存在代码文件所在目录
+        if csv_path is None:
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            self.csv_path = os.path.join(current_dir, "stm32_data.csv")
+        else:
+            self.csv_path = csv_path
+        self.ser_timeout = timeout
+        self.chunk_read = 128
+        
+        # 串口对象
+        self.ser: Optional[serial.Serial] = None
+        self.stop_flag = False
+        
+        # 线程对象
+        self.rx_thread: Optional[threading.Thread] = None
+        self.tx_thread: Optional[threading.Thread] = None
+        
+        # ==== 接收（下位机->上位机）：固定 1+13+1 = 15 字节 ====
+        self.RX_HEAD = 0x3E
+        self.RX_TAIL = 0x3E
+        self.RX_FRAME_LEN = 1 + 13 + 1  # 15
+        
+        # ==== 发送（上位机->下位机）：固定 1+9+1 = 11 字节 ====
+        self.TX_HEAD = 0x3E
+        self.TX_TAIL = 0xE3  # 协议图中标注 E3 作为帧尾
+        self.TX_FRAME_LEN = 1 + 9 + 1  # 11
+    
+    def open_serial(self, port: Optional[str] = None, baudrate: Optional[int] = None, timeout: Optional[float] = None) -> Optional[serial.Serial]:
+        """打开串口"""
+        port = port or self.port
+        baudrate = baudrate or self.baudrate
+        timeout = timeout or self.ser_timeout
+        try:
+            ser = serial.Serial(port, baudrate, timeout=timeout)
+            print(f"[OK] 串口 {port} 已打开，波特率 {baudrate}")
+            ser.reset_input_buffer()
+            ser.reset_output_buffer()
+            self.ser = ser
+            return ser
+        except serial.SerialException as e:
+            print(f"[ERR] 无法打开串口 {port}: {e}")
+            return None
+
+    def close_serial(self):
+        """关闭串口"""
+        if self.ser and self.ser.is_open:
+            self.ser.close()
+            print("[INFO] 串口已关闭")
+
+    @staticmethod
+    def u16_be(h: int, l: int) -> int:
+        """将两个字节组合成16位无符号整数（大端序）"""
+        return ((h & 0xFF) << 8) | (l & 0xFF)
+
+    @staticmethod
+    def split_u16_be(val: int) -> tuple:
+        """返回 (高字节, 低字节)，输入会夹到 0..65535"""
+        v = int(max(0, min(65535, int(val))))
+        return (v >> 8) & 0xFF, v & 0xFF
+
+    # ================== 接收：固定15字节 ==================
+    def parse_rx_payload(self, dat13: bytes) -> Optional[Dict[str, Any]]:
+        """解析 13 字节数据区（下位机发送到上位机）"""
+        if len(dat13) != 13:
+            return None
+        current_mA      = self.u16_be(dat13[0], dat13[1])
+        voltage_mV      = self.u16_be(dat13[2], dat13[3])
+        temperature_raw = self.u16_be(dat13[4], dat13[5])
+        tds_ppm         = self.u16_be(dat13[6], dat13[7])
+        gas_sccm        = self.u16_be(dat13[8], dat13[9])
+        liquid_mL       = self.u16_be(dat13[10], dat13[11])
+        ph_raw          = dat13[12] & 0xFF
+
+        return {
+            "Current_mA": current_mA,
+            "Voltage_mV": voltage_mV,
+            "Temperature_C": round(temperature_raw / 100.0, 2),
+            "TDS_ppm": tds_ppm,
+            "GasFlow_sccm": gas_sccm,
+            "LiquidFlow_mL": liquid_mL,
+            "pH": round(ph_raw / 10.0, 2)
+        }
+
+    def try_parse_rx_frame(self, frame15: bytes) -> Optional[Dict[str, Any]]:
+        """尝试解析接收帧"""
+        if len(frame15) != self.RX_FRAME_LEN:
+            return None
+        if frame15[0] != self.RX_HEAD or frame15[-1] != self.RX_TAIL:
+            return None
+        return self.parse_rx_payload(frame15[1:-1])
+
+    def rx_thread_fn(self):
+        """接收线程函数"""
+        headers = ["Timestamp", "Current_mA", "Voltage_mV",
+                   "Temperature_C", "TDS_ppm", "GasFlow_sccm", "LiquidFlow_mL", "pH"]
+
+        new_file = not os.path.exists(self.csv_path)
+        f = open(self.csv_path, mode='a', newline='', encoding='utf-8')
+        writer = csv.writer(f)
+        if new_file:
+            writer.writerow(headers)
+            f.flush()
+
+        buf = deque(maxlen=8192)
+        print(f"[RX] 开始接收（帧长 {self.RX_FRAME_LEN} 字节）；写入：{self.csv_path}")
+
+        try:
+            while not self.stop_flag and self.ser and self.ser.is_open:
+                chunk = self.ser.read(self.chunk_read)
+                if chunk:
+                    buf.extend(chunk)
+                    while True:
+                        # 找帧头
+                        try:
+                            start = next(i for i, b in enumerate(buf) if b == self.RX_HEAD)
+                        except StopIteration:
+                            buf.clear()
+                            break
+                        if start > 0:
+                            for _ in range(start):
+                                buf.popleft()
+                        if len(buf) < self.RX_FRAME_LEN:
+                            break
+                        candidate = bytes([buf[i] for i in range(self.RX_FRAME_LEN)])
+                        if candidate[-1] == self.RX_TAIL:
+                            parsed = self.try_parse_rx_frame(candidate)
+                            for _ in range(self.RX_FRAME_LEN):
+                                buf.popleft()
+                            if parsed:
+                                ts = time.strftime("%Y-%m-%d %H:%M:%S")
+                                row = [ts,
+                                       parsed["Current_mA"], parsed["Voltage_mV"],
+                                       parsed["Temperature_C"], parsed["TDS_ppm"],
+                                       parsed["GasFlow_sccm"], parsed["LiquidFlow_mL"],
+                                       parsed["pH"]]
+                                writer.writerow(row)
+                                f.flush()
+                                # 若不想打印可注释下一行
+                                # print(f"[{ts}] I={parsed['Current_mA']} mA, V={parsed['Voltage_mV']} mV, "
+                                #       f"T={parsed['Temperature_C']} °C, TDS={parsed['TDS_ppm']}, "
+                                #       f"Gas={parsed['GasFlow_sccm']} sccm, Liq={parsed['LiquidFlow_mL']} mL, pH={parsed['pH']}")
+                        else:
+                            # 头不变，尾不对，丢1字节继续对齐
+                            buf.popleft()
+                else:
+                    time.sleep(0.01)
+        finally:
+            f.close()
+            print("[RX] 接收线程退出，CSV 已关闭")
+
+    # ================== 发送：固定11字节 ==================
+    def build_tx_frame(self, mode: int, current_ma: int, voltage_mv: int, temp_c: float, ki: float, pump_percent: float) -> bytes:
+        """
+        发送帧：HEAD + [mode, I_hi, I_lo, V_hi, V_lo, T_hi, T_lo, Ki_byte, Pump_byte] + TAIL
+        - mode: 0=恒压, 1=恒流
+        - current_ma: mA (0..65535)
+        - voltage_mv: mV (0..65535)
+        - temp_c: ℃，将 *100 后拆分为高/低字节
+        - ki: 0.0..20.0  -> byte = round(ki * 10) 夹到 0..200
+        - pump_percent: 0..100 -> byte = round(pump * 2) 夹到 0..200
+        """
+        mode_b = 1 if int(mode) == 1 else 0
+
+        i_hi, i_lo = self.split_u16_be(current_ma)
+        v_hi, v_lo = self.split_u16_be(voltage_mv)
+
+        t100 = int(round(float(temp_c) * 100.0))
+        t_hi, t_lo = self.split_u16_be(t100)
+
+        ki_b = int(max(0, min(200, round(float(ki) * 10))))
+        pump_b = int(max(0, min(200, round(float(pump_percent) * 2))))
+
+        return bytes((
+            self.TX_HEAD,
+            mode_b,
+            i_hi, i_lo,
+            v_hi, v_lo,
+            t_hi, t_lo,
+            ki_b,
+            pump_b,
+            self.TX_TAIL
+        ))
+
+    def tx_thread_fn(self):
+        """
+        发送线程函数
+        用户输入 6 个用逗号分隔的数值：
+        mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent
+        例如： 0,1000,500,0,0,50
+        """
+        print("\n输入 6 个值（用英文逗号分隔），顺序为：")
+        print("mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent")
+        print("示例恒压：0,500,1000,25,0,100   （stop 结束）\n")
+        print("示例恒流：1,1000,500,25,0,100   （stop 结束）\n")
+        print("示例恒流：1,2000,500,25,0,100   （stop 结束）\n")
+        # 1,2000,500,25,0,100
+
+        while not self.stop_flag and self.ser and self.ser.is_open:
+            try:
+                line = input(">>> ").strip()
+            except EOFError:
+                self.stop_flag = True
+                break
+
+            if not line:
+                continue
+            if line.lower() == "stop":
+                self.stop_flag = True
+                print("[SYS] 停止程序")
+                break
+
+            try:
+                parts = [p.strip() for p in line.split(",")]
+                if len(parts) != 6:
+                    raise ValueError("需要 6 个逗号分隔的数值")
+                mode = int(parts[0])
+                i_ma = int(float(parts[1]))
+                v_mv = int(float(parts[2]))
+                t_c  = float(parts[3])
+                ki   = float(parts[4])
+                pump = float(parts[5])
+
+                frame = self.build_tx_frame(mode, i_ma, v_mv, t_c, ki, pump)
+                self.ser.write(frame)
+                print("[TX]", " ".join(f"{b:02X}" for b in frame))
+            except Exception as e:
+                print("[TX] 输入/打包失败：", e)
+                print("格式：mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent")
+                continue
+    
+    def start(self):
+        """启动电解水平台"""
+        self.ser = self.open_serial()
+        if self.ser:
+            try:
+                self.rx_thread = threading.Thread(target=self.rx_thread_fn, daemon=True)
+                self.tx_thread = threading.Thread(target=self.tx_thread_fn, daemon=True)
+                self.rx_thread.start()
+                self.tx_thread.start()
+                print("[INFO] 电解水平台已启动")
+                self.tx_thread.join()  # 等待用户输入线程结束（输入 stop）
+            finally:
+                self.close_serial()
+    
+    def stop(self):
+        """停止电解水平台"""
+        self.stop_flag = True
+        if self.rx_thread and self.rx_thread.is_alive():
+            self.rx_thread.join(timeout=2.0)
+        if self.tx_thread and self.tx_thread.is_alive():
+            self.tx_thread.join(timeout=2.0)
+        self.close_serial()
+        print("[INFO] 电解水平台已停止")
+
+
+# ================== 主入口 ==================
+if __name__ == "__main__":
+    # 创建一个简单的 Deck 用于测试
+    from pylabrobot.resources import Deck
+    
+    deck = Deck()
+    platform = ElectrolysisWaterPlatform(deck)
+    platform.start()

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
-import re
-import traceback
-from typing import List, Sequence, Optional, Literal, Union, Iterator, Dict, Any, Callable, Set, cast
-from collections import Counter
+
 import asyncio
 import time
-import pprint as pp
+import traceback
+from collections import Counter
+from typing import List, Sequence, Optional, Literal, Union, Iterator, Dict, Any, Callable, Set, cast
+
 from pylabrobot.liquid_handling import LiquidHandler, LiquidHandlerBackend, LiquidHandlerChatterboxBackend, Strictness
 from pylabrobot.liquid_handling.liquid_handler import TipPresenceProbingMethod
 from pylabrobot.liquid_handling.standard import GripDirection
@@ -25,6 +25,8 @@ from pylabrobot.resources import (
     Tip,
 )
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class LiquidHandlerMiddleware(LiquidHandler):
     def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8):
@@ -536,6 +538,7 @@ class LiquidHandlerMiddleware(LiquidHandler):
 class LiquidHandlerAbstract(LiquidHandlerMiddleware):
     """Extended LiquidHandler with additional operations."""
     support_touch_tip = True
+    _ros_node: BaseROS2DeviceNode
 
     def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8):
         """Initialize a LiquidHandler.
@@ -548,8 +551,11 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
         self.group_info = dict()
         super().__init__(backend, deck, simulator, channel_num)
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     @classmethod
-    def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]):
+    def set_liquid(cls, wells: list[Well], liquid_names: list[str], volumes: list[float]):
         """Set the liquid in a well."""
         for well, liquid_name, volume in zip(wells, liquid_names, volumes):
             well.set_liquids([(liquid_name, volume)])  # type: ignore
@@ -1081,7 +1087,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 print(f"Waiting time: {msg}")
                 print(f"Current time: {time.strftime('%H:%M:%S')}")
                 print(f"Time to finish: {time.strftime('%H:%M:%S', time.localtime(time.time() + seconds))}")
-            await asyncio.sleep(seconds)
+            await self._ros_node.sleep(seconds)
             if msg:
                 print(f"Done: {msg}")
                 print(f"Current time: {time.strftime('%H:%M:%S')}")

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -30,6 +30,7 @@ from pylabrobot.liquid_handling.standard import (
 from pylabrobot.resources import Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash
 
 from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class PRCXIError(RuntimeError):
@@ -162,6 +163,10 @@ class PRCXI9300Handler(LiquidHandlerAbstract):
         )
         super().__init__(backend=self._unilabos_backend, deck=deck, simulator=simulator, channel_num=channel_num)
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        super().post_init(ros_node)
+        self._unilabos_backend.post_init(ros_node)
+
     def set_liquid(self, wells: list[Well], liquid_names: list[str], volumes: list[float]):
         return super().set_liquid(wells, liquid_names, volumes)
 
@@ -424,6 +429,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
 
     _num_channels = 8  # 默认通道数为 8
     _is_reset_ok = False
+    _ros_node: BaseROS2DeviceNode
 
     @property
     def is_reset_ok(self) -> bool:
@@ -456,6 +462,9 @@ class PRCXI9300Backend(LiquidHandlerBackend):
         self._execute_setup = setup
         self.debug = debug
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     def create_protocol(self, protocol_name):
         self.protocol_name = protocol_name
         self.steps_todo_list = []
@@ -500,7 +509,7 @@ class PRCXI9300Backend(LiquidHandlerBackend):
                 self.api_client.call("IAutomation", "Reset")
                 while not self.is_reset_ok:
                     print("Waiting for PRCXI9300 to reset...")
-                    await asyncio.sleep(1)
+                    await self._ros_node.sleep(1)
                 print("PRCXI9300 reset successfully.")
         except ConnectionRefusedError as e:
             raise RuntimeError(
@@ -533,7 +542,9 @@ class PRCXI9300Backend(LiquidHandlerBackend):
             tipspot_index = tipspot.parent.children.index(tipspot)
             tip_columns.append(tipspot_index // 8)
         if len(set(tip_columns)) != 1:
-            raise ValueError("All pickups must be from the same tip column. Found different columns: " + str(tip_columns))
+            raise ValueError(
+                "All pickups must be from the same tip column. Found different columns: " + str(tip_columns)
+            )
         PlateNo = plate_indexes[0] + 1
         hole_col = tip_columns[0] + 1
         hole_row = 1
@@ -1109,12 +1120,15 @@ class PRCXI9300Api:
             "LiquidDispensingMethod": liquid_method,
         }
 
+
 class DefaultLayout:
 
     def __init__(self, product_name: str = "PRCXI9300"):
         self.labresource = {}
         if product_name not in ["PRCXI9300", "PRCXI9320"]:
-            raise ValueError(f"Unsupported product_name: {product_name}. Only 'PRCXI9300' and 'PRCXI9320' are supported.")
+            raise ValueError(
+                f"Unsupported product_name: {product_name}. Only 'PRCXI9300' and 'PRCXI9320' are supported."
+            )
 
         if product_name == "PRCXI9300":
             self.rows = 2
@@ -1129,25 +1143,93 @@ class DefaultLayout:
             self.layout = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
             self.trash_slot = 16
             self.waste_liquid_slot = 12
-            self.default_layout =  {"MatrixId":f"{time.time()}","MatrixName":f"{time.time()}","MatrixCount":16,"WorkTablets":
-            [{"Number": 1, "Code": "T1", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 2, "Code": "T2", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 3, "Code": "T3", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 4, "Code": "T4", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 5, "Code": "T5", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 6, "Code": "T6", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 7, "Code": "T7", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 8, "Code": "T8", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 9, "Code": "T9", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 10, "Code": "T10", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 11, "Code": "T11", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 12, "Code": "T12", "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0}},  # 这个设置成废液槽，用储液槽表示
-  {"Number": 13, "Code": "T13", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 14, "Code": "T14", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 15, "Code": "T15", "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0}},
-  {"Number": 16, "Code": "T16", "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0}} # 这个设置成垃圾桶，用储液槽表示
-]
-}
+            self.default_layout = {
+                "MatrixId": f"{time.time()}",
+                "MatrixName": f"{time.time()}",
+                "MatrixCount": 16,
+                "WorkTablets": [
+                    {
+                        "Number": 1,
+                        "Code": "T1",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 2,
+                        "Code": "T2",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 3,
+                        "Code": "T3",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 4,
+                        "Code": "T4",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 5,
+                        "Code": "T5",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 6,
+                        "Code": "T6",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 7,
+                        "Code": "T7",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 8,
+                        "Code": "T8",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 9,
+                        "Code": "T9",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 10,
+                        "Code": "T10",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 11,
+                        "Code": "T11",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 12,
+                        "Code": "T12",
+                        "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0},
+                    },  # 这个设置成废液槽，用储液槽表示
+                    {
+                        "Number": 13,
+                        "Code": "T13",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 14,
+                        "Code": "T14",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 15,
+                        "Code": "T15",
+                        "Material": {"uuid": "57b1e4711e9e4a32b529f3132fc5931f", "materialEnum": 0},
+                    },
+                    {
+                        "Number": 16,
+                        "Code": "T16",
+                        "Material": {"uuid": "730067cf07ae43849ddf4034299030e9", "materialEnum": 0},
+                    },  # 这个设置成垃圾桶，用储液槽表示
+                ],
+            }
 
     def get_layout(self) -> Dict[str, Any]:
         return {
@@ -1155,7 +1237,7 @@ class DefaultLayout:
             "columns": self.columns,
             "layout": self.layout,
             "trash_slot": self.trash_slot,
-            "waste_liquid_slot": self.waste_liquid_slot
+            "waste_liquid_slot": self.waste_liquid_slot,
         }
 
     def get_trash_slot(self) -> int:
@@ -1178,17 +1260,19 @@ class DefaultLayout:
         reserved_positions = {12, 16}
         available_positions = [i for i in range(1, 17) if i not in reserved_positions]
 
-            # 计算总需求
+        # 计算总需求
         total_needed = sum(count for _, _, count in needs)
         if total_needed > len(available_positions):
-            raise ValueError(f"需要 {total_needed} 个位置，但只有 {len(available_positions)} 个可用位置（排除位置12和16）")
+            raise ValueError(
+                f"需要 {total_needed} 个位置，但只有 {len(available_positions)} 个可用位置（排除位置12和16）"
+            )
 
             # 依次分配位置
         current_pos = 0
         for reagent_name, material_name, count in needs:
 
-            material_uuid = self.labresource[material_name]['uuid']
-            material_enum = self.labresource[material_name]['materialEnum']
+            material_uuid = self.labresource[material_name]["uuid"]
+            material_enum = self.labresource[material_name]["materialEnum"]
 
             for _ in range(count):
                 if current_pos >= len(available_positions):
@@ -1196,17 +1280,18 @@ class DefaultLayout:
 
                 position = available_positions[current_pos]
                 # 找到对应的tablet并更新
-                for tablet in self.default_layout['WorkTablets']:
-                    if tablet['Number'] == position:
-                        tablet['Material']['uuid'] = material_uuid
-                        tablet['Material']['materialEnum'] = material_enum
-                        layout_list.append(dict(reagent_name=reagent_name, material_name=material_name, positions=position))
+                for tablet in self.default_layout["WorkTablets"]:
+                    if tablet["Number"] == position:
+                        tablet["Material"]["uuid"] = material_uuid
+                        tablet["Material"]["materialEnum"] = material_enum
+                        layout_list.append(
+                            dict(reagent_name=reagent_name, material_name=material_name, positions=position)
+                        )
                         break
                 current_pos += 1
         return self.default_layout, layout_list
 
 
-
 if __name__ == "__main__":
     # Example usage
     # 1. 用导出的json，给每个T1 T2板子设定相应的物料，如果是孔板和枪头盒，要对应区分
@@ -1302,10 +1387,7 @@ if __name__ == "__main__":
 
     # # # plate2.set_well_liquids(plate_2_liquids)
 
-
-
-
-    # handler = PRCXI9300Handler(deck=deck, host="10.181.214.132", port=9999, 
+    # handler = PRCXI9300Handler(deck=deck, host="10.181.214.132", port=9999,
     #                            timeout=10.0, setup=False, debug=False,
     #                            simulator=True,
     #                            matrix_id="71593",
@@ -1391,10 +1473,7 @@ if __name__ == "__main__":
     # # input("Press Enter to continue...")  # Wait for user input before proceeding
     # # print("PRCXI9300Handler initialized with deck and host settings.")
 
-
-
-### 9320 ###
-
+    ### 9320 ###
 
     deck = PRCXI9300Deck(name="PRCXI_Deck", size_x=100, size_y=100, size_z=100)
 
@@ -1412,12 +1491,15 @@ if __name__ == "__main__":
         new_plate: PRCXI9300Container = PRCXI9300Container.deserialize(well_containers)
         return new_plate
 
-    def get_tip_rack(name: str, child_prefix: str="tip") -> PRCXI9300Container:
+    def get_tip_rack(name: str, child_prefix: str = "tip") -> PRCXI9300Container:
         tip_racks = opentrons_96_tiprack_10ul(name).serialize()
         tip_rack = PRCXI9300Container(
-            name=name, size_x=50, size_y=50, size_z=10, category="tip_rack", ordering=collections.OrderedDict({
-                k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()
-            })
+            name=name,
+            size_x=50,
+            size_y=50,
+            size_z=10,
+            category="tip_rack",
+            ordering=collections.OrderedDict({k: f"{child_prefix}_{k}" for k, v in tip_racks["ordering"].items()}),
         )
         tip_rack_serialized = tip_rack.serialize()
         tip_rack_serialized["parent_name"] = deck.name
@@ -1629,6 +1711,7 @@ if __name__ == "__main__":
     )
     backend: PRCXI9300Backend = handler.backend
     from pylabrobot.resources import set_volume_tracking
+
     set_volume_tracking(enabled=True)
     # res = backend.api_client.get_all_materials()
     asyncio.run(handler.setup())  # Initialize the handler and setup the connection
@@ -1640,10 +1723,10 @@ if __name__ == "__main__":
 
     for well in plate13.get_all_items():
         # well_pos = well.name.split("_")[1]       # 走一行
-        # if well_pos.startswith("A"):             
-        if well.name.startswith("PlateT13"):       # 走整个Plate
+        # 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]))
@@ -1652,26 +1735,25 @@ if __name__ == "__main__":
     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)
-# 第二个情景：多个孔往多个孔加液(但是个数得对应)
-    plate_2_liquids = handler.set_group("water", plate2.children[:23], [300]*23)
-    plate5_liquids = handler.set_group("master_mix", plate5.children[:23], [100]*23)
+    # 第二个情景：多个孔往多个孔加液(但是个数得对应)
+    plate_2_liquids = handler.set_group("water", plate2.children[:23], [300] * 23)
+    plate5_liquids = handler.set_group("master_mix", plate5.children[:23], [100] * 23)
 
     # plate11.set_well_liquids([("Water", 100) if (i % 8 == 0 and i // 8 < 6) else (None, 100) for i in range(96)])  # Set liquids for every 8 wells in plate8
 
     # plate11.set_well_liquids([("Water", 100) if (i % 8 == 0 and i // 8 < 6) else (None, 100) for i in range(96)])  # Set liquids for every 8 wells in plate8
 
-#     A = tree_to_list([resource_plr_to_ulab(deck)])
-#     # with open("deck.json", "w", encoding="utf-8") as f:
-#     #     json.dump(A, f, indent=4, ensure_ascii=False)
+    #     A = tree_to_list([resource_plr_to_ulab(deck)])
+    #     # with open("deck.json", "w", encoding="utf-8") as f:
+    #     #     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
+    #     print(plate11.get_well(0).tracker.get_used_volume())
+    # Initialize the backend and setup the connection
     asyncio.run(handler.transfer_group("water", "master_mix", 10))  # Reset tip tracking
 
-
     # asyncio.run(handler.pick_up_tips([plate8.children[8]],[0]))
     # print(plate8.children[8])
     # asyncio.run(handler.run_protocol())
@@ -1685,121 +1767,118 @@ if __name__ == "__main__":
     # print(plate1.children[0])
     # asyncio.run(handler.discard_tips([0]))
 
-#     asyncio.run(handler.add_liquid(
-#     asp_vols=[10]*7,
-#     dis_vols=[10]*7,
-#     reagent_sources=plate11.children[:7],
-#     targets=plate1.children[2:9],
-#     use_channels=[0],
-#     flow_rates=[None] * 7,
-#     offsets=[Coordinate(0, 0, 0)] * 7,
-#     liquid_height=[None] * 7,
-#     blow_out_air_volume=[None] * 2,
-#     delays=None,
-#     mix_time=3,
-#     mix_vol=5,
-#     spread="custom",
-# ))
+    #     asyncio.run(handler.add_liquid(
+    #     asp_vols=[10]*7,
+    #     dis_vols=[10]*7,
+    #     reagent_sources=plate11.children[:7],
+    #     targets=plate1.children[2:9],
+    #     use_channels=[0],
+    #     flow_rates=[None] * 7,
+    #     offsets=[Coordinate(0, 0, 0)] * 7,
+    #     liquid_height=[None] * 7,
+    #     blow_out_air_volume=[None] * 2,
+    #     delays=None,
+    #     mix_time=3,
+    #     mix_vol=5,
+    #     spread="custom",
+    # ))
 
     # asyncio.run(handler.run_protocol())  # Run the protocol
 
+    # # #     asyncio.run(handler.transfer_liquid(
+    # # #     asp_vols=[10]*2,
+    # # #     dis_vols=[10]*2,
+    # # #     sources=plate11.children[:2],
+    # # #     targets=plate11.children[-2:],
+    # # #     use_channels=[0],
+    # # #     offsets=[Coordinate(0, 0, 0)] * 4,
+    # # #     liquid_height=[None] * 2,
+    # # #     blow_out_air_volume=[None] * 2,
+    # # #     delays=None,
+    # # #     mix_times=3,
+    # # #     mix_vol=5,
+    # # #     spread="wide",
+    # # #     tip_racks=[plate8]
+    # # # ))
 
+    # # #     asyncio.run(handler.remove_liquid(
+    # # #     vols=[10]*2,
+    # # #     sources=plate11.children[:2],
+    # # #     waste_liquid=plate11.children[43],
+    # # #     use_channels=[0],
+    # # #     offsets=[Coordinate(0, 0, 0)] * 4,
+    # # #     liquid_height=[None] * 2,
+    # # #     blow_out_air_volume=[None] * 2,
+    # # #     delays=None,
+    # # #     spread="wide"
+    # # # ))
+    # #     asyncio.run(handler.run_protocol())
 
+    # #     # asyncio.run(handler.discard_tips())
+    # #     # asyncio.run(handler.mix(well_containers.children[:8
+    # #     # ], mix_time=3, mix_vol=50, height_to_bottom=0.5, offsets=Coordinate(0, 0, 0), mix_rate=100))
+    # #     #print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
 
-# # #     asyncio.run(handler.transfer_liquid(
-# # #     asp_vols=[10]*2,
-# # #     dis_vols=[10]*2,
-# # #     sources=plate11.children[:2],
-# # #     targets=plate11.children[-2:],
-# # #     use_channels=[0],
-# # #     offsets=[Coordinate(0, 0, 0)] * 4,
-# # #     liquid_height=[None] * 2,
-# # #     blow_out_air_volume=[None] * 2,
-# # #     delays=None,
-# # #     mix_times=3,
-# # #     mix_vol=5,
-# # #     spread="wide",
-# # #     tip_racks=[plate8]
-# # # ))
-
-# # #     asyncio.run(handler.remove_liquid(
-# # #     vols=[10]*2,
-# # #     sources=plate11.children[:2],
-# # #     waste_liquid=plate11.children[43],
-# # #     use_channels=[0],
-# # #     offsets=[Coordinate(0, 0, 0)] * 4,
-# # #     liquid_height=[None] * 2,
-# # #     blow_out_air_volume=[None] * 2,
-# # #     delays=None,
-# # #     spread="wide"
-# # # ))
-# #     asyncio.run(handler.run_protocol())
-
-# #     # asyncio.run(handler.discard_tips())
-# #     # asyncio.run(handler.mix(well_containers.children[:8
-# #     # ], mix_time=3, mix_vol=50, height_to_bottom=0.5, offsets=Coordinate(0, 0, 0), mix_rate=100))
-# #     #print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
-
-
-# #     # asyncio.run(handler.remove_liquid(
-# #     #     vols=[100]*16,
-# #     #     sources=well_containers.children[-16:],
-# #     #     waste_liquid=well_containers.children[:16], # 这个有些奇怪，但是好像也只能这么写
-# #     #     use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
-# #     #     flow_rates=[None] * 32,
-# #     #     offsets=[Coordinate(0, 0, 0)] * 32,
-# #     #     liquid_height=[None] * 32,
-# #     #     blow_out_air_volume=[None] * 32,
-# #     #     spread="wide",
-# #     # ))
-# #     # asyncio.run(handler.transfer_liquid(
-# #     #     asp_vols=[100]*16,
-# #     #     dis_vols=[100]*16,
-# #     #     tip_racks=[tip_rack],
-# #     #     sources=well_containers.children[-16:],
-# #     #     targets=well_containers.children[:16],
-# #     #     use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
-# #     #     offsets=[Coordinate(0, 0, 0)] * 32,
-# #     #     asp_flow_rates=[None] * 16,
-# #     #     dis_flow_rates=[None] * 16,
-# #     #     liquid_height=[None] * 32,
-# #     #     blow_out_air_volume=[None] * 32,
-# #     #     mix_times=3,
-# #     #     mix_vol=50,
-# #     #     spread="wide",
-# #     # ))
-#       # print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
-# #     # input("pick_up_tips add step")
-     #asyncio.run(handler.run_protocol())  # Run the protocol
-# #     # input("Running protocol...")
-# #     # input("Press Enter to continue...")  # Wait for user input before proceeding
-# #     # print("PRCXI9300Handler initialized with deck and host settings.")
-
-
-# 一些推荐版位组合的测试样例：
-
-# 一些推荐版位组合的测试样例：
+    # #     # asyncio.run(handler.remove_liquid(
+    # #     #     vols=[100]*16,
+    # #     #     sources=well_containers.children[-16:],
+    # #     #     waste_liquid=well_containers.children[:16], # 这个有些奇怪，但是好像也只能这么写
+    # #     #     use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
+    # #     #     flow_rates=[None] * 32,
+    # #     #     offsets=[Coordinate(0, 0, 0)] * 32,
+    # #     #     liquid_height=[None] * 32,
+    # #     #     blow_out_air_volume=[None] * 32,
+    # #     #     spread="wide",
+    # #     # ))
+    # #     # asyncio.run(handler.transfer_liquid(
+    # #     #     asp_vols=[100]*16,
+    # #     #     dis_vols=[100]*16,
+    # #     #     tip_racks=[tip_rack],
+    # #     #     sources=well_containers.children[-16:],
+    # #     #     targets=well_containers.children[:16],
+    # #     #     use_channels=[0, 1, 2, 3, 4, 5, 6, 7],
+    # #     #     offsets=[Coordinate(0, 0, 0)] * 32,
+    # #     #     asp_flow_rates=[None] * 16,
+    # #     #     dis_flow_rates=[None] * 16,
+    # #     #     liquid_height=[None] * 32,
+    # #     #     blow_out_air_volume=[None] * 32,
+    # #     #     mix_times=3,
+    # #     #     mix_vol=50,
+    # #     #     spread="wide",
+    # #     # ))
+    #       # print(json.dumps(handler._unilabos_backend.steps_todo_list, indent=2))  # Print matrix info
+    # #     # input("pick_up_tips add step")
+    # asyncio.run(handler.run_protocol())  # Run the protocol
+    # #     # input("Running protocol...")
+    # #     # input("Press Enter to continue...")  # Wait for user input before proceeding
+    # #     # print("PRCXI9300Handler initialized with deck and host settings.")
 
+    # 一些推荐版位组合的测试样例：
 
+    # 一些推荐版位组合的测试样例：
 
     with open("prcxi_material.json", "r") as f:
         material_info = json.load(f)
 
     layout = DefaultLayout("PRCXI9320")
     layout.add_lab_resource(material_info)
-    MatrixLayout_1, dict_1 = layout.recommend_layout([
-        ("reagent_1", "96 细胞培养皿", 3),
-        ("reagent_2", "12道储液槽", 1),
-        ("reagent_3", "200μL Tip头", 7),
-        ("reagent_4", "10μL加长 Tip头", 1),
-    ])
+    MatrixLayout_1, dict_1 = layout.recommend_layout(
+        [
+            ("reagent_1", "96 细胞培养皿", 3),
+            ("reagent_2", "12道储液槽", 1),
+            ("reagent_3", "200μL Tip头", 7),
+            ("reagent_4", "10μL加长 Tip头", 1),
+        ]
+    )
     print(dict_1)
-    MatrixLayout_2, dict_2 = layout.recommend_layout([
-        ("reagent_1", "96深孔板", 4),
-        ("reagent_2", "12道储液槽", 1),
-        ("reagent_3", "200μL Tip头", 1),
-        ("reagent_4", "10μL加长 Tip头", 1),
-    ])
+    MatrixLayout_2, dict_2 = layout.recommend_layout(
+        [
+            ("reagent_1", "96深孔板", 4),
+            ("reagent_2", "12道储液槽", 1),
+            ("reagent_3", "200μL Tip头", 1),
+            ("reagent_4", "10μL加长 Tip头", 1),
+        ]
+    )
 
 # with open("prcxi_material.json", "r") as f:
 #     material_info = json.load(f)

unilabos/devices/pump_and_valve/runze_async.py

@@ -8,6 +8,8 @@ import serial.tools.list_ports
 from serial import Serial
 from serial.serialutil import SerialException
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class RunzeSyringePumpMode(Enum):
     Normal = 0
@@ -77,6 +79,8 @@ class RunzeSyringePumpInfo:
 
 
 class RunzeSyringePumpAsync:
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, port: str, address: str = "1", volume: float = 25000, mode: RunzeSyringePumpMode = None):
         self.port = port
         self.address = address
@@ -102,6 +106,9 @@ class RunzeSyringePumpAsync:
         self._run_future: Optional[Future[Any]] = None
         self._run_lock = Lock()
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     def _adjust_total_steps(self):
         self.total_steps = 6000 if self.mode == RunzeSyringePumpMode.Normal else 48000
         self.total_steps_vel = 48000 if self.mode == RunzeSyringePumpMode.AccuratePosVel else 6000
@@ -182,7 +189,7 @@ class RunzeSyringePumpAsync:
             try:
                 await self._query(command)
                 while True:
-                    await asyncio.sleep(0.5)  # Wait for 0.5 seconds before polling again
+                    await self._ros_node.sleep(0.5)  # Wait for 0.5 seconds before polling again
                     
                     status = await self.query_device_status()
                     if status == '`':
@@ -364,7 +371,7 @@ class RunzeSyringePumpAsync:
         if self._read_task:
             raise RunzeSyringePumpConnectionError
 
-        self._read_task = asyncio.create_task(self._read_loop())
+        self._read_task = self._ros_node.create_task(self._read_loop())
 
         try:
             await self.query_device_status()

unilabos/devices/virtual/virtual_centrifuge.py

@@ -3,9 +3,13 @@ import logging
 import time as time_module
 from typing import Dict, Any, Optional
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class VirtualCentrifuge:
     """Virtual centrifuge device - 简化版，只保留核心功能"""
+    
+    _ros_node: BaseROS2DeviceNode
 
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -32,6 +36,9 @@ class VirtualCentrifuge:
         for key, value in kwargs.items():
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
+    
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
 
     async def initialize(self) -> bool:
         """Initialize virtual centrifuge"""
@@ -132,7 +139,7 @@ class VirtualCentrifuge:
                     break
                 
                 # 每秒更新一次
-                await asyncio.sleep(1.0)
+                await self._ros_node.sleep(1.0)
             
             # 离心完成
             self.data.update({

unilabos/devices/virtual/virtual_column.py

@@ -2,9 +2,13 @@ import asyncio
 import logging
 from typing import Dict, Any, Optional
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 class VirtualColumn:
     """Virtual column device for RunColumn protocol 🏛️"""
     
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
         if device_id is None and 'id' in kwargs:
@@ -28,6 +32,9 @@ class VirtualColumn:
         print(f"🏛️ === 虚拟色谱柱 {self.device_id} 已创建 === ✨")
         print(f"📏 柱参数: 流速={self._max_flow_rate}mL/min | 长度={self._column_length}cm | 直径={self._column_diameter}cm 🔬")
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     async def initialize(self) -> bool:
         """Initialize virtual column 🚀"""
         self.logger.info(f"🔧 初始化虚拟色谱柱 {self.device_id} ✨")
@@ -101,7 +108,7 @@ class VirtualColumn:
         step_time = separation_time / steps
         
         for i in range(steps):
-            await asyncio.sleep(step_time)
+            await self._ros_node.sleep(step_time)
             
             progress = (i + 1) / steps * 100
             volume_processed = (i + 1) * 5.0  # 假设每步处理5mL

unilabos/devices/virtual/virtual_filter.py

@@ -4,70 +4,76 @@ import time as time_module
 from typing import Dict, Any, Optional
 
 from unilabos.compile.utils.vessel_parser import get_vessel
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class VirtualFilter:
     """Virtual filter device - 完全按照 Filter.action 规范 🌊"""
-    
+
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
-        if device_id is None and 'id' in kwargs:
-            device_id = kwargs.pop('id')
-        if config is None and 'config' in kwargs:
-            config = kwargs.pop('config')
-        
+        if device_id is None and "id" in kwargs:
+            device_id = kwargs.pop("id")
+        if config is None and "config" in kwargs:
+            config = kwargs.pop("config")
+
         self.device_id = device_id or "unknown_filter"
         self.config = config or {}
         self.logger = logging.getLogger(f"VirtualFilter.{self.device_id}")
         self.data = {}
-        
+
         # 从config或kwargs中获取配置参数
-        self.port = self.config.get('port') or kwargs.get('port', 'VIRTUAL')
-        self._max_temp = self.config.get('max_temp') or kwargs.get('max_temp', 100.0)
-        self._max_stir_speed = self.config.get('max_stir_speed') or kwargs.get('max_stir_speed', 1000.0)
-        self._max_volume = self.config.get('max_volume') or kwargs.get('max_volume', 500.0)
-        
+        self.port = self.config.get("port") or kwargs.get("port", "VIRTUAL")
+        self._max_temp = self.config.get("max_temp") or kwargs.get("max_temp", 100.0)
+        self._max_stir_speed = self.config.get("max_stir_speed") or kwargs.get("max_stir_speed", 1000.0)
+        self._max_volume = self.config.get("max_volume") or kwargs.get("max_volume", 500.0)
+
         # 处理其他kwargs参数
-        skip_keys = {'port', 'max_temp', 'max_stir_speed', 'max_volume'}
+        skip_keys = {"port", "max_temp", "max_stir_speed", "max_volume"}
         for key, value in kwargs.items():
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
-    
+
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     async def initialize(self) -> bool:
         """Initialize virtual filter 🚀"""
         self.logger.info(f"🔧 初始化虚拟过滤器 {self.device_id} ✨")
-        
+
         # 按照 Filter.action 的 feedback 字段初始化
-        self.data.update({
-            "status": "Idle",
-            "progress": 0.0,           # Filter.action feedback
-            "current_temp": 25.0,      # Filter.action feedback
-            "filtered_volume": 0.0,    # Filter.action feedback
-            "message": "Ready for filtration"
-        })
-        
+        self.data.update(
+            {
+                "status": "Idle",
+                "progress": 0.0,  # Filter.action feedback
+                "current_temp": 25.0,  # Filter.action feedback
+                "filtered_volume": 0.0,  # Filter.action feedback
+                "message": "Ready for filtration",
+            }
+        )
+
         self.logger.info(f"✅ 过滤器 {self.device_id} 初始化完成 🌊")
         return True
-    
+
     async def cleanup(self) -> bool:
         """Cleanup virtual filter 🧹"""
         self.logger.info(f"🧹 清理虚拟过滤器 {self.device_id} 🔚")
-        
-        self.data.update({
-            "status": "Offline"
-        })
-        
+
+        self.data.update({"status": "Offline"})
+
         self.logger.info(f"✅ 过滤器 {self.device_id} 清理完成 💤")
         return True
-    
+
     async def filter(
-        self, 
+        self,
         vessel: dict,
         filtrate_vessel: dict = {},
-        stir: bool = False, 
-        stir_speed: float = 300.0, 
-        temp: float = 25.0, 
-        continue_heatchill: bool = False, 
-        volume: float = 0.0
+        stir: bool = False,
+        stir_speed: float = 300.0,
+        temp: float = 25.0,
+        continue_heatchill: bool = False,
+        volume: float = 0.0,
     ) -> bool:
         """Execute filter action - 完全按照 Filter.action 参数 🌊"""
         vessel_id, _ = get_vessel(vessel)
@@ -79,59 +85,52 @@ class VirtualFilter:
             temp = 25.0  # 0度自动设置为室温
             self.logger.info(f"🌡️ 温度自动调整: {original_temp}°C → {temp}°C (室温) 🏠")
         elif temp < 4.0:
-            temp = 4.0   # 小于4度自动设置为4度
+            temp = 4.0  # 小于4度自动设置为4度
             self.logger.info(f"🌡️ 温度自动调整: {original_temp}°C → {temp}°C (最低温度) ❄️")
-        
+
         self.logger.info(f"🌊 开始过滤操作: {vessel_id} → {filtrate_vessel_id} 🚰")
         self.logger.info(f"  🌪️ 搅拌: {stir} ({stir_speed} RPM)")
         self.logger.info(f"  🌡️ 温度: {temp}°C")
         self.logger.info(f"  💧 体积: {volume}mL")
         self.logger.info(f"  🔥 保持加热: {continue_heatchill}")
-        
+
         # 验证参数
         if temp > self._max_temp or temp < 4.0:
             error_msg = f"🌡️ 温度 {temp}°C 超出范围 (4-{self._max_temp}°C) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"Error: 温度超出范围 ⚠️",
-                "message": error_msg
-            })
+            self.data.update({"status": f"Error: 温度超出范围 ⚠️", "message": error_msg})
             return False
-        
+
         if stir and stir_speed > self._max_stir_speed:
             error_msg = f"🌪️ 搅拌速度 {stir_speed} RPM 超出范围 (0-{self._max_stir_speed} RPM) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"Error: 搅拌速度超出范围 ⚠️",
-                "message": error_msg
-            })
+            self.data.update({"status": f"Error: 搅拌速度超出范围 ⚠️", "message": error_msg})
             return False
-        
+
         if volume > self._max_volume:
             error_msg = f"💧 过滤体积 {volume} mL 超出范围 (0-{self._max_volume} mL) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"Error",
-                "message": error_msg
-            })
+            self.data.update({"status": f"Error", "message": error_msg})
             return False
-        
+
         # 开始过滤
         filter_volume = volume if volume > 0 else 50.0
         self.logger.info(f"🚀 开始过滤 {filter_volume}mL 液体 💧")
-        
-        self.data.update({
-            "status": f"Running",
-            "current_temp": temp,
-            "filtered_volume": 0.0,
-            "progress": 0.0,
-            "message": f"🚀 Starting filtration: {vessel_id} → {filtrate_vessel_id}"
-        })
-        
+
+        self.data.update(
+            {
+                "status": f"Running",
+                "current_temp": temp,
+                "filtered_volume": 0.0,
+                "progress": 0.0,
+                "message": f"🚀 Starting filtration: {vessel_id} → {filtrate_vessel_id}",
+            }
+        )
+
         try:
             # 过滤过程 - 实时更新进度
             start_time = time_module.time()
-            
+
             # 根据体积和搅拌估算过滤时间
             base_time = filter_volume / 5.0  # 5mL/s 基础速度
             if stir:
@@ -140,78 +139,79 @@ class VirtualFilter:
             if temp > 50.0:
                 base_time *= 0.7  # 高温加速过滤
                 self.logger.info(f"🔥 高温加速过滤，预计时间减少30% ⚡")
-            
+
             filter_time = max(base_time, 10.0)  # 最少10秒
             self.logger.info(f"⏱️ 预计过滤时间: {filter_time:.1f}秒 ⌛")
-            
+
             while True:
                 current_time = time_module.time()
                 elapsed = current_time - start_time
                 remaining = max(0, filter_time - elapsed)
                 progress = min(100.0, (elapsed / filter_time) * 100)
                 current_filtered = (progress / 100.0) * filter_volume
-                
+
                 # 更新状态 - 按照 Filter.action feedback 字段
                 status_msg = f"🌊 过滤中: {vessel}"
                 if stir:
                     status_msg += f" | 🌪️ 搅拌: {stir_speed} RPM"
                 status_msg += f" | 🌡️ {temp}°C | 📊 {progress:.1f}% | 💧 已过滤: {current_filtered:.1f}mL"
-                
-                self.data.update({
-                    "progress": progress,               # Filter.action feedback
-                    "current_temp": temp,              # Filter.action feedback
-                    "filtered_volume": current_filtered, # Filter.action feedback
-                    "status": "Running",
-                    "message": f"🌊 Filtering: {progress:.1f}% complete, {current_filtered:.1f}mL filtered"
-                })
-                
+
+                self.data.update(
+                    {
+                        "progress": progress,  # Filter.action feedback
+                        "current_temp": temp,  # Filter.action feedback
+                        "filtered_volume": current_filtered,  # Filter.action feedback
+                        "status": "Running",
+                        "message": f"🌊 Filtering: {progress:.1f}% complete, {current_filtered:.1f}mL filtered",
+                    }
+                )
+
                 # 进度日志（每25%打印一次）
                 if progress >= 25 and progress % 25 < 1:
                     self.logger.info(f"📊 过滤进度: {progress:.0f}% | 💧 {current_filtered:.1f}mL 完成 ✨")
-                
+
                 if remaining <= 0:
                     break
-                
-                await asyncio.sleep(1.0)
-            
+
+                await self._ros_node.sleep(1.0)
+
             # 过滤完成
             final_temp = temp if continue_heatchill else 25.0
             final_status = f"✅ 过滤完成: {vessel} | 💧 {filter_volume}mL → {filtrate_vessel}"
             if continue_heatchill:
                 final_status += " | 🔥 继续加热搅拌"
                 self.logger.info(f"🔥 继续保持加热搅拌状态 🌪️")
-            
-            self.data.update({
-                "status": final_status,
-                "progress": 100.0,                    # Filter.action feedback
-                "current_temp": final_temp,           # Filter.action feedback
-                "filtered_volume": filter_volume,     # Filter.action feedback
-                "message": f"✅ Filtration completed: {filter_volume}mL filtered from {vessel_id}"
-            })
-            
+
+            self.data.update(
+                {
+                    "status": final_status,
+                    "progress": 100.0,  # Filter.action feedback
+                    "current_temp": final_temp,  # Filter.action feedback
+                    "filtered_volume": filter_volume,  # Filter.action feedback
+                    "message": f"✅ Filtration completed: {filter_volume}mL filtered from {vessel_id}",
+                }
+            )
+
             self.logger.info(f"🎉 过滤完成! 💧 {filter_volume}mL 从 {vessel_id} 过滤到 {filtrate_vessel_id} ✨")
             self.logger.info(f"📊 最终状态: 温度 {final_temp}°C | 进度 100% | 体积 {filter_volume}mL 🏁")
             return True
-            
+
         except Exception as e:
             error_msg = f"过滤过程中发生错误: {str(e)} 💥"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"Error",
-                "message": f"❌ Filtration failed: {str(e)}"
-            })
+            self.data.update({"status": f"Error", "message": f"❌ Filtration failed: {str(e)}"})
             return False
-    
+
     # === 核心状态属性 - 按照 Filter.action feedback 字段 ===
     @property
     def status(self) -> str:
         return self.data.get("status", "❓ Unknown")
-    
+
     @property
     def progress(self) -> float:
         """Filter.action feedback 字段 📊"""
         return self.data.get("progress", 0.0)
-    
+
     @property
     def current_temp(self) -> float:
         """Filter.action feedback 字段 🌡️"""
@@ -230,15 +230,15 @@ class VirtualFilter:
     @property
     def message(self) -> str:
         return self.data.get("message", "")
-    
+
     @property
     def max_temp(self) -> float:
         return self._max_temp
-    
+
     @property
     def max_stir_speed(self) -> float:
         return self._max_stir_speed
-    
+
     @property
     def max_volume(self) -> float:
-        return self._max_volume
+        return self._max_volume

unilabos/devices/virtual/virtual_heatchill.py

@@ -3,9 +3,13 @@ import logging
 import time as time_module  # 重命名time模块，避免与参数冲突
 from typing import Dict, Any
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 class VirtualHeatChill:
     """Virtual heat chill device for HeatChillProtocol testing 🌡️"""
     
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
         if device_id is None and 'id' in kwargs:
@@ -35,6 +39,9 @@ class VirtualHeatChill:
         print(f"🌡️ === 虚拟温控设备 {self.device_id} 已创建 === ✨")
         print(f"🔥 温度范围: {self._min_temp}°C ~ {self._max_temp}°C | 🌪️ 最大搅拌: {self._max_stir_speed} RPM")
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     async def initialize(self) -> bool:
         """Initialize virtual heat chill 🚀"""
         self.logger.info(f"🔧 初始化虚拟温控设备 {self.device_id} ✨")
@@ -177,7 +184,7 @@ class VirtualHeatChill:
                 break
             
             # 等待1秒后再次检查
-            await asyncio.sleep(1.0)
+            await self._ros_node.sleep(1.0)
         
         # 操作完成
         final_stir_info = f" | 🌪️ 搅拌: {stir_speed} RPM" if stir else ""

unilabos/devices/virtual/virtual_rotavap.py

@@ -3,13 +3,19 @@ import logging
 import time as time_module
 from typing import Dict, Any, Optional
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
+
 def debug_print(message):
     """调试输出 🔍"""
     print(f"🌪️ [ROTAVAP] {message}", flush=True)
 
+
 class VirtualRotavap:
     """Virtual rotary evaporator device - 简化版，只保留核心功能 🌪️"""
 
+    _ros_node: BaseROS2DeviceNode
+
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
         if device_id is None and "id" in kwargs:
@@ -38,56 +44,65 @@ class VirtualRotavap:
         print(f"🌪️ === 虚拟旋转蒸发仪 {self.device_id} 已创建 === ✨")
         print(f"🔥 温度范围: 10°C ~ {self._max_temp}°C | 🌀 转速范围: 10 ~ {self._max_rotation_speed} RPM")
 
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+
     async def initialize(self) -> bool:
         """Initialize virtual rotary evaporator 🚀"""
         self.logger.info(f"🔧 初始化虚拟旋转蒸发仪 {self.device_id} ✨")
-        
+
         # 只保留核心状态
-        self.data.update({
-            "status": "🏠 待机中",
-            "rotavap_state": "Ready",  # Ready, Evaporating, Completed, Error
-            "current_temp": 25.0,
-            "target_temp": 25.0,
-            "rotation_speed": 0.0,
-            "vacuum_pressure": 1.0,  # 大气压
-            "evaporated_volume": 0.0,
-            "progress": 0.0,
-            "remaining_time": 0.0,
-            "message": "🌪️ Ready for evaporation"
-        })
-        
+        self.data.update(
+            {
+                "status": "🏠 待机中",
+                "rotavap_state": "Ready",  # Ready, Evaporating, Completed, Error
+                "current_temp": 25.0,
+                "target_temp": 25.0,
+                "rotation_speed": 0.0,
+                "vacuum_pressure": 1.0,  # 大气压
+                "evaporated_volume": 0.0,
+                "progress": 0.0,
+                "remaining_time": 0.0,
+                "message": "🌪️ Ready for evaporation",
+            }
+        )
+
         self.logger.info(f"✅ 旋转蒸发仪 {self.device_id} 初始化完成 🌪️")
-        self.logger.info(f"📊 设备规格: 温度范围 10°C ~ {self._max_temp}°C | 转速范围 10 ~ {self._max_rotation_speed} RPM")
+        self.logger.info(
+            f"📊 设备规格: 温度范围 10°C ~ {self._max_temp}°C | 转速范围 10 ~ {self._max_rotation_speed} RPM"
+        )
         return True
 
     async def cleanup(self) -> bool:
         """Cleanup virtual rotary evaporator 🧹"""
         self.logger.info(f"🧹 清理虚拟旋转蒸发仪 {self.device_id} 🔚")
-        
-        self.data.update({
-            "status": "💤 离线",
-            "rotavap_state": "Offline",
-            "current_temp": 25.0,
-            "rotation_speed": 0.0,
-            "vacuum_pressure": 1.0,
-            "message": "💤 System offline"
-        })
-        
+
+        self.data.update(
+            {
+                "status": "💤 离线",
+                "rotavap_state": "Offline",
+                "current_temp": 25.0,
+                "rotation_speed": 0.0,
+                "vacuum_pressure": 1.0,
+                "message": "💤 System offline",
+            }
+        )
+
         self.logger.info(f"✅ 旋转蒸发仪 {self.device_id} 清理完成 💤")
         return True
 
     async def evaporate(
-        self, 
-        vessel: str, 
-        pressure: float = 0.1, 
-        temp: float = 60.0, 
+        self,
+        vessel: str,
+        pressure: float = 0.1,
+        temp: float = 60.0,
         time: float = 180.0,
         stir_speed: float = 100.0,
         solvent: str = "",
-        **kwargs
+        **kwargs,
     ) -> bool:
         """Execute evaporate action - 简化版 🌪️"""
-        
+
         # 🔧 新增：确保time参数是数值类型
         if isinstance(time, str):
             try:
@@ -98,31 +113,31 @@ class VirtualRotavap:
         elif not isinstance(time, (int, float)):
             self.logger.error(f"❌ 时间参数类型无效: {type(time)}，使用默认值180.0秒")
             time = 180.0
-        
+
         # 确保time是float类型; 并加速
         time = float(time) / 10.0
-        
+
         # 🔧 简化处理：如果vessel就是设备自己，直接操作
         if vessel == self.device_id:
             debug_print(f"🎯 在设备 {self.device_id} 上直接执行蒸发操作")
             actual_vessel = self.device_id
         else:
             actual_vessel = vessel
-        
+
         # 参数预处理
         if solvent:
             self.logger.info(f"🧪 识别到溶剂: {solvent}")
             # 根据溶剂调整参数
             solvent_lower = solvent.lower()
-            if any(s in solvent_lower for s in ['water', 'aqueous']):
+            if any(s in solvent_lower for s in ["water", "aqueous"]):
                 temp = max(temp, 80.0)
                 pressure = max(pressure, 0.2)
                 self.logger.info(f"💧 水系溶剂：调整参数 → 温度 {temp}°C, 压力 {pressure} bar")
-            elif any(s in solvent_lower for s in ['ethanol', 'methanol', 'acetone']):
+            elif any(s in solvent_lower for s in ["ethanol", "methanol", "acetone"]):
                 temp = min(temp, 50.0)
                 pressure = min(pressure, 0.05)
                 self.logger.info(f"⚡ 易挥发溶剂：调整参数 → 温度 {temp}°C, 压力 {pressure} bar")
-        
+
         self.logger.info(f"🌪️ 开始蒸发操作: {actual_vessel}")
         self.logger.info(f"  🥽 容器: {actual_vessel}")
         self.logger.info(f"  🌡️ 温度: {temp}°C")
@@ -131,126 +146,140 @@ class VirtualRotavap:
         self.logger.info(f"  🌀 转速: {stir_speed} RPM")
         if solvent:
             self.logger.info(f"  🧪 溶剂: {solvent}")
-        
+
         # 验证参数
         if temp > self._max_temp or temp < 10.0:
             error_msg = f"🌡️ 温度 {temp}°C 超出范围 (10-{self._max_temp}°C) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"❌ 错误: 温度超出范围",
-                "rotavap_state": "Error",
-                "current_temp": 25.0,
-                "progress": 0.0,
-                "evaporated_volume": 0.0,
-                "message": error_msg
-            })
+            self.data.update(
+                {
+                    "status": f"❌ 错误: 温度超出范围",
+                    "rotavap_state": "Error",
+                    "current_temp": 25.0,
+                    "progress": 0.0,
+                    "evaporated_volume": 0.0,
+                    "message": error_msg,
+                }
+            )
             return False
 
         if stir_speed > self._max_rotation_speed or stir_speed < 10.0:
             error_msg = f"🌀 旋转速度 {stir_speed} RPM 超出范围 (10-{self._max_rotation_speed} RPM) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"❌ 错误: 转速超出范围",
-                "rotavap_state": "Error",
-                "current_temp": 25.0,
-                "progress": 0.0,
-                "evaporated_volume": 0.0,
-                "message": error_msg
-            })
+            self.data.update(
+                {
+                    "status": f"❌ 错误: 转速超出范围",
+                    "rotavap_state": "Error",
+                    "current_temp": 25.0,
+                    "progress": 0.0,
+                    "evaporated_volume": 0.0,
+                    "message": error_msg,
+                }
+            )
             return False
 
         if pressure < 0.01 or pressure > 1.0:
             error_msg = f"💨 真空度 {pressure} bar 超出范围 (0.01-1.0 bar) ⚠️"
             self.logger.error(f"❌ {error_msg}")
-            self.data.update({
-                "status": f"❌ 错误: 压力超出范围",
-                "rotavap_state": "Error",
-                "current_temp": 25.0,
-                "progress": 0.0,
-                "evaporated_volume": 0.0,
-                "message": error_msg
-            })
+            self.data.update(
+                {
+                    "status": f"❌ 错误: 压力超出范围",
+                    "rotavap_state": "Error",
+                    "current_temp": 25.0,
+                    "progress": 0.0,
+                    "evaporated_volume": 0.0,
+                    "message": error_msg,
+                }
+            )
             return False
 
         # 开始蒸发 - 🔧 现在time已经确保是float类型
         self.logger.info(f"🚀 启动蒸发程序! 预计用时 {time/60:.1f}分钟 ⏱️")
-        
-        self.data.update({
-            "status": f"🌪️ 蒸发中: {actual_vessel}",
-            "rotavap_state": "Evaporating",
-            "current_temp": temp,
-            "target_temp": temp,
-            "rotation_speed": stir_speed,
-            "vacuum_pressure": pressure,
-            "remaining_time": time,
-            "progress": 0.0,
-            "evaporated_volume": 0.0,
-            "message": f"🌪️ Evaporating {actual_vessel} at {temp}°C, {pressure} bar, {stir_speed} RPM"
-        })
+
+        self.data.update(
+            {
+                "status": f"🌪️ 蒸发中: {actual_vessel}",
+                "rotavap_state": "Evaporating",
+                "current_temp": temp,
+                "target_temp": temp,
+                "rotation_speed": stir_speed,
+                "vacuum_pressure": pressure,
+                "remaining_time": time,
+                "progress": 0.0,
+                "evaporated_volume": 0.0,
+                "message": f"🌪️ Evaporating {actual_vessel} at {temp}°C, {pressure} bar, {stir_speed} RPM",
+            }
+        )
 
         try:
             # 蒸发过程 - 实时更新进度
             start_time = time_module.time()
             total_time = time
             last_logged_progress = 0
-            
+
             while True:
                 current_time = time_module.time()
                 elapsed = current_time - start_time
                 remaining = max(0, total_time - elapsed)
                 progress = min(100.0, (elapsed / total_time) * 100)
-                
+
                 # 模拟蒸发体积 - 根据溶剂类型调整
-                if solvent and any(s in solvent.lower() for s in ['water', 'aqueous']):
+                if solvent and any(s in solvent.lower() for s in ["water", "aqueous"]):
                     evaporated_vol = progress * 0.6  # 水系溶剂蒸发慢
-                elif solvent and any(s in solvent.lower() for s in ['ethanol', 'methanol', 'acetone']):
+                elif solvent and any(s in solvent.lower() for s in ["ethanol", "methanol", "acetone"]):
                     evaporated_vol = progress * 1.0  # 易挥发溶剂蒸发快
                 else:
                     evaporated_vol = progress * 0.8  # 默认蒸发量
-                
+
                 # 🔧 更新状态 - 确保包含所有必需字段
                 status_msg = f"🌪️ 蒸发中: {actual_vessel} | 🌡️ {temp}°C | 💨 {pressure} bar | 🌀 {stir_speed} RPM | 📊 {progress:.1f}% | ⏰ 剩余: {remaining:.0f}s"
-                
-                self.data.update({
-                    "remaining_time": remaining,
-                    "progress": progress,
-                    "evaporated_volume": evaporated_vol,
-                    "current_temp": temp,
-                    "status": status_msg,
-                    "message": f"🌪️ Evaporating: {progress:.1f}% complete, 💧 {evaporated_vol:.1f}mL evaporated, ⏰ {remaining:.0f}s remaining"
-                })
-                
+
+                self.data.update(
+                    {
+                        "remaining_time": remaining,
+                        "progress": progress,
+                        "evaporated_volume": evaporated_vol,
+                        "current_temp": temp,
+                        "status": status_msg,
+                        "message": f"🌪️ Evaporating: {progress:.1f}% complete, 💧 {evaporated_vol:.1f}mL evaporated, ⏰ {remaining:.0f}s remaining",
+                    }
+                )
+
                 # 进度日志（每25%打印一次）
                 if progress >= 25 and int(progress) % 25 == 0 and int(progress) != last_logged_progress:
-                    self.logger.info(f"📊 蒸发进度: {progress:.0f}% | 💧 已蒸发: {evaporated_vol:.1f}mL | ⏰ 剩余: {remaining:.0f}s ✨")
+                    self.logger.info(
+                        f"📊 蒸发进度: {progress:.0f}% | 💧 已蒸发: {evaporated_vol:.1f}mL | ⏰ 剩余: {remaining:.0f}s ✨"
+                    )
                     last_logged_progress = int(progress)
-                
+
                 # 时间到了，退出循环
                 if remaining <= 0:
                     break
-                
+
                 # 每秒更新一次
-                await asyncio.sleep(1.0)
-            
+                await self._ros_node.sleep(1.0)
+
             # 蒸发完成
-            if solvent and any(s in solvent.lower() for s in ['water', 'aqueous']):
+            if solvent and any(s in solvent.lower() for s in ["water", "aqueous"]):
                 final_evaporated = 60.0  # 水系溶剂
-            elif solvent and any(s in solvent.lower() for s in ['ethanol', 'methanol', 'acetone']):
+            elif solvent and any(s in solvent.lower() for s in ["ethanol", "methanol", "acetone"]):
                 final_evaporated = 100.0  # 易挥发溶剂
             else:
                 final_evaporated = 80.0  # 默认
-            
-            self.data.update({
-                "status": f"✅ 蒸发完成: {actual_vessel} | 💧 蒸发量: {final_evaporated:.1f}mL",
-                "rotavap_state": "Completed",
-                "evaporated_volume": final_evaporated,
-                "progress": 100.0,
-                "current_temp": temp,
-                "remaining_time": 0.0,
-                "rotation_speed": 0.0,
-                "vacuum_pressure": 1.0,
-                "message": f"✅ Evaporation completed: {final_evaporated}mL evaporated from {actual_vessel}"
-            })
+
+            self.data.update(
+                {
+                    "status": f"✅ 蒸发完成: {actual_vessel} | 💧 蒸发量: {final_evaporated:.1f}mL",
+                    "rotavap_state": "Completed",
+                    "evaporated_volume": final_evaporated,
+                    "progress": 100.0,
+                    "current_temp": temp,
+                    "remaining_time": 0.0,
+                    "rotation_speed": 0.0,
+                    "vacuum_pressure": 1.0,
+                    "message": f"✅ Evaporation completed: {final_evaporated}mL evaporated from {actual_vessel}",
+                }
+            )
 
             self.logger.info(f"🎉 蒸发操作完成! ✨")
             self.logger.info(f"📊 蒸发结果:")
@@ -262,24 +291,26 @@ class VirtualRotavap:
             self.logger.info(f"  ⏱️ 总用时: {total_time:.0f}s")
             if solvent:
                 self.logger.info(f"  🧪 处理溶剂: {solvent} 🏁")
-            
+
             return True
 
         except Exception as e:
             # 出错处理
             error_msg = f"蒸发过程中发生错误: {str(e)} 💥"
             self.logger.error(f"❌ {error_msg}")
-            
-            self.data.update({
-                "status": f"❌ 蒸发错误: {str(e)}",
-                "rotavap_state": "Error",
-                "current_temp": 25.0,
-                "progress": 0.0,
-                "evaporated_volume": 0.0,
-                "rotation_speed": 0.0,
-                "vacuum_pressure": 1.0,
-                "message": f"❌ Evaporation failed: {str(e)}"
-            })
+
+            self.data.update(
+                {
+                    "status": f"❌ 蒸发错误: {str(e)}",
+                    "rotavap_state": "Error",
+                    "current_temp": 25.0,
+                    "progress": 0.0,
+                    "evaporated_volume": 0.0,
+                    "rotation_speed": 0.0,
+                    "vacuum_pressure": 1.0,
+                    "message": f"❌ Evaporation failed: {str(e)}",
+                }
+            )
             return False
 
     # === 核心状态属性 ===

unilabos/devices/virtual/virtual_separator.py

@@ -2,9 +2,13 @@ import asyncio
 import logging
 from typing import Dict, Any, Optional
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class VirtualSeparator:
     """Virtual separator device for SeparateProtocol testing"""
+    
+    _ros_node: BaseROS2DeviceNode
 
     def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
         # 处理可能的不同调用方式
@@ -35,6 +39,9 @@ class VirtualSeparator:
         for key, value in kwargs.items():
             if key not in skip_keys and not hasattr(self, key):
                 setattr(self, key, value)
+    
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
 
     async def initialize(self) -> bool:
         """Initialize virtual separator"""
@@ -119,14 +126,14 @@ class VirtualSeparator:
         for repeat in range(repeats):
             # 搅拌阶段
             for progress in range(0, 51, 10):
-                await asyncio.sleep(simulation_time / (repeats * 10))
+                await self._ros_node.sleep(simulation_time / (repeats * 10))
                 overall_progress = ((repeat * 100) + (progress * 0.5)) / repeats
                 self.data["progress"] = overall_progress
                 self.data["message"] = f"第{repeat+1}次分离 - 搅拌中 ({progress}%)"
 
             # 静置分相阶段
             for progress in range(50, 101, 10):
-                await asyncio.sleep(simulation_time / (repeats * 10))
+                await self._ros_node.sleep(simulation_time / (repeats * 10))
                 overall_progress = ((repeat * 100) + (progress * 0.5)) / repeats
                 self.data["progress"] = overall_progress
                 self.data["message"] = f"第{repeat+1}次分离 - 静置分相中 ({progress}%)"

unilabos/devices/virtual/virtual_solenoid_valve.py

@@ -2,11 +2,16 @@ import time
 import asyncio
 from typing import Union
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class VirtualSolenoidValve:
     """
     虚拟电磁阀门 - 简单的开关型阀门，只有开启和关闭两个状态
     """
+    
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: dict = None, **kwargs):
         # 从配置中获取参数，提供默认值
         if config is None:
@@ -21,6 +26,9 @@ class VirtualSolenoidValve:
         self._status = "Idle"
         self._valve_state = "Closed"  # "Open" or "Closed"
         self._is_open = False
+    
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
 
     async def initialize(self) -> bool:
         """初始化设备"""
@@ -63,7 +71,7 @@ class VirtualSolenoidValve:
         self._status = "Busy"
         
         # 模拟阀门响应时间
-        await asyncio.sleep(self.response_time)
+        await self._ros_node.sleep(self.response_time)
         
         # 处理不同的命令格式
         if isinstance(command, str):

unilabos/devices/virtual/virtual_solid_dispenser.py

@@ -3,6 +3,8 @@ import logging
 import re
 from typing import Dict, Any, Optional
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 class VirtualSolidDispenser:
     """
     虚拟固体粉末加样器 - 用于处理 Add Protocol 中的固体试剂添加 ⚗️
@@ -13,6 +15,8 @@ class VirtualSolidDispenser:
     - 简单反馈：成功/失败 + 消息 📊
     """
     
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         self.device_id = device_id or "virtual_solid_dispenser"
         self.config = config or {}
@@ -32,6 +36,9 @@ class VirtualSolidDispenser:
         print(f"⚗️ === 虚拟固体分配器 {self.device_id} 创建成功! === ✨")
         print(f"📊 设备规格: 最大容量 {self.max_capacity}g | 精度 {self.precision}g 🎯")
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     async def initialize(self) -> bool:
         """初始化固体加样器 🚀"""
         self.logger.info(f"🔧 初始化固体分配器 {self.device_id} ✨")
@@ -263,7 +270,7 @@ class VirtualSolidDispenser:
             
             for i in range(steps):
                 progress = (i + 1) / steps * 100
-                await asyncio.sleep(step_time)
+                await self._ros_node.sleep(step_time)
                 if i % 2 == 0:  # 每隔一步显示进度
                     self.logger.debug(f"📊 加样进度: {progress:.0f}% | {amount_emoji} 正在分配 {reagent}...")
             

unilabos/devices/virtual/virtual_stirrer.py

@@ -3,9 +3,13 @@ import logging
 import time as time_module
 from typing import Dict, Any
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 class VirtualStirrer:
     """Virtual stirrer device for StirProtocol testing - 功能完整版 🌪️"""
     
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: Dict[str, Any] = None, **kwargs):
         # 处理可能的不同调用方式
         if device_id is None and 'id' in kwargs:
@@ -34,6 +38,9 @@ class VirtualStirrer:
         print(f"🌪️ === 虚拟搅拌器 {self.device_id} 已创建 === ✨")
         print(f"🔧 速度范围: {self._min_speed} ~ {self._max_speed} RPM | 📱 端口: {self.port}")
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     async def initialize(self) -> bool:
         """Initialize virtual stirrer 🚀"""
         self.logger.info(f"🔧 初始化虚拟搅拌器 {self.device_id} ✨")
@@ -134,7 +141,7 @@ class VirtualStirrer:
             if remaining <= 0:
                 break
             
-            await asyncio.sleep(1.0)
+            await self._ros_node.sleep(1.0)
         
         self.logger.info(f"✅ 搅拌阶段完成! 🌪️ {stir_speed} RPM × {stir_time}s")
         
@@ -176,7 +183,7 @@ class VirtualStirrer:
                 if remaining <= 0:
                     break
                 
-                await asyncio.sleep(1.0)
+                await self._ros_node.sleep(1.0)
             
             self.logger.info(f"✅ 沉降阶段完成! 🛑 静置 {settling_time}s")
         

unilabos/devices/virtual/virtual_transferpump.py

@@ -4,6 +4,8 @@ from enum import Enum
 from typing import Union, Optional
 import logging
 
+from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
+
 
 class VirtualPumpMode(Enum):
     Normal = 0
@@ -14,6 +16,8 @@ class VirtualPumpMode(Enum):
 class VirtualTransferPump:
     """虚拟转移泵类 - 模拟泵的基本功能，无需实际硬件 🚰"""
     
+    _ros_node: BaseROS2DeviceNode
+    
     def __init__(self, device_id: str = None, config: dict = None, **kwargs):
         """
         初始化虚拟转移泵
@@ -53,6 +57,9 @@ class VirtualTransferPump:
         print(f"💨 快速模式: {'启用' if self._fast_mode else '禁用'} | 移动时间: {self._fast_move_time}s | 喷射时间: {self._fast_dispense_time}s")
         print(f"📊 最大容量: {self.max_volume}mL | 端口: {self.port}")
     
+    def post_init(self, ros_node: BaseROS2DeviceNode):
+        self._ros_node = ros_node
+    
     async def initialize(self) -> bool:
         """初始化虚拟泵 🚀"""
         self.logger.info(f"🔧 初始化虚拟转移泵 {self.device_id} ✨")
@@ -104,7 +111,7 @@ class VirtualTransferPump:
     async def _simulate_operation(self, duration: float):
         """模拟操作延时 ⏱️"""
         self._status = "Busy"
-        await asyncio.sleep(duration)
+        await self._ros_node.sleep(duration)
         self._status = "Idle"
     
     def _calculate_duration(self, volume: float, velocity: float = None) -> float:
@@ -223,7 +230,7 @@ class VirtualTransferPump:
                     
                     # 等待一小步时间
                     if i < steps and step_duration > 0:
-                        await asyncio.sleep(step_duration)
+                        await self._ros_node.sleep(step_duration)
             else:
                 # 移动距离很小，直接完成
                 self._position = target_position
@@ -341,7 +348,7 @@ class VirtualTransferPump:
         
         # 短暂停顿
         self.logger.debug("⏸️ 短暂停顿...")
-        await asyncio.sleep(0.1)
+        await self._ros_node.sleep(0.1)
         
         # 排液
         await self.dispense(volume, dispense_velocity)

unilabos/devices/workstation/README.md

@@ -37,7 +37,7 @@ def _initialize_material_system(self, deck_config: Dict[str, Any], children_conf
 **定义在**: `workstation_base.py`
 
 **设计目的**：
-- 提供外部物料系统（如Bioyong、LIMS等）集成的标准接口
+- 提供外部物料系统（如Bioyond、LIMS等）集成的标准接口
 - 双向同步：从外部系统同步到本地deck，以及将本地变更同步到外部系统
 - 处理外部系统的变更通知
 
@@ -59,7 +59,7 @@ async def handle_external_change(self, change_info: Dict[str, Any]) -> bool:
 **扩展功能**：
 - HTTP报送接收服务集成
 - 具体工作流实现（液体转移、板洗等）
-- Bioyong物料系统同步器示例
+- Bioyond物料系统同步器示例
 - 外部报送处理方法
 
 ## 技术栈
@@ -142,11 +142,11 @@ success = workstation.execute_workflow("liquid_transfer", {
 ### 3. 外部系统集成
 
 ```python
-class BioyongResourceSynchronizer(ResourceSynchronizer):
-    """Bioyong系统同步器"""
+class BioyondResourceSynchronizer(ResourceSynchronizer):
+    """Bioyond系统同步器"""
     
     async def sync_from_external(self) -> bool:
-        # 从Bioyong API获取物料
+        # 从Bioyond API获取物料
         external_materials = await self._fetch_bioyong_materials()
         
         # 转换并添加到本地deck

unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_yihua_YB.json

@@ -1,8 +1,23 @@
 {
   "nodes": [
+    {
+      "id": "bioyond_cell_workstation",
+      "name": "配液分液工站",
+      "children": [
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "bioyond_cell",
+      "config": {
+          "protocol_type": [],
+          "station_resource": {}
+
+      },
+      "data": {}
+  },
     {
       "id": "BatteryStation",
-      "name": "扣电工作站",
+      "name": "扣电组装工作站",
       "children": [
           "coin_cell_deck"
       ],
@@ -98,7 +113,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine_four",
+        "type": "MagazineHolder_4",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -139,7 +154,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -234,7 +249,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -329,7 +344,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -424,7 +439,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -522,7 +537,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine_four",
+        "type": "MagazineHolder_4",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -563,7 +578,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -658,7 +673,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -753,7 +768,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -848,7 +863,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -948,7 +963,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -991,7 +1006,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1086,7 +1101,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1181,7 +1196,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1276,7 +1291,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1371,7 +1386,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1466,7 +1481,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1566,7 +1581,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -1609,7 +1624,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1704,7 +1719,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1799,7 +1814,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1894,7 +1909,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1989,7 +2004,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2084,7 +2099,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2184,7 +2199,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2227,7 +2242,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2322,7 +2337,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2417,7 +2432,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2512,7 +2527,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2607,7 +2622,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2702,7 +2717,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2802,7 +2817,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2845,7 +2860,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2940,7 +2955,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3035,7 +3050,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3130,7 +3145,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3225,7 +3240,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3320,7 +3335,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3420,7 +3435,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -3463,7 +3478,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3558,7 +3573,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3653,7 +3668,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3748,7 +3763,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3843,7 +3858,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3938,7 +3953,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4038,7 +4053,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -4081,7 +4096,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4176,7 +4191,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4271,7 +4286,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4366,7 +4381,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4461,7 +4476,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4556,7 +4571,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,

unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv

@@ -0,0 +1,7 @@
+material_name
+LiPF6
+LiDFOB
+DTD
+LiFSI
+LiPO2F2
+

unilabos/devices/workstation/bioyond_studio/config.py

@@ -2,128 +2,330 @@
 """
 配置文件 - 包含所有配置信息和映射关系
 """
+import os
 
-# API配置
+# ==================== API 基础配置 ====================
+# BioyondCellWorkstation 默认配置（包含所有必需参数）
 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': '反应器取出'
+    # API 连接配置
+    # "api_host": os.getenv("BIOYOND_API_HOST", "http://172.16.1.143:44389"),#实机
+    "api_host": os.getenv("BIOYOND_API_HOST", "http://172.16.11.219:44388"),# 仿真机
+    "api_key": os.getenv("BIOYOND_API_KEY", "8A819E5C"),
+    "timeout": int(os.getenv("BIOYOND_TIMEOUT", "30")),
+    
+    # 报送配置
+    "report_token": os.getenv("BIOYOND_REPORT_TOKEN", "CHANGE_ME_TOKEN"),
+    
+    # HTTP 服务配置
+    "HTTP_host": os.getenv("BIOYOND_HTTP_HOST", "172.16.11.2"),  # HTTP服务监听地址，监听计算机飞连ip地址
+    "HTTP_port": int(os.getenv("BIOYOND_HTTP_PORT", "8080")),
+    "debug_mode": False,# 调试模式
 }
 
 # 库位映射配置
-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': '',
+WAREHOUSE_MAPPING = {
+    "粉末加样头堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+            "B01": "3a19da56-1379-2424-d751-fe6e94cef938",
+            "C01": "3a19da56-1379-271c-03e3-6bdb590e395e",
+            "D01": "3a19da56-1379-277f-2b1b-0d11f7cf92c6",
+            "E01": "3a19da56-1379-2f1c-a15b-e01db90eb39a",
+            "F01": "3a19da56-1379-3fa1-846b-088158ac0b3d",
+            "G01": "3a19da56-1379-5aeb-d0cd-d3b4609d66e1",
+            "H01": "3a19da56-1379-6077-8258-bdc036870b78",
+            "I01": "3a19da56-1379-863b-a120-f606baf04617",
+            "J01": "3a19da56-1379-8a74-74e5-35a9b41d4fd5",
+            "K01": "3a19da56-1379-b270-b7af-f18773918abe",
+            "L01": "3a19da56-1379-ba54-6d78-fd770a671ffc",
+            "M01": "3a19da56-1379-c22d-c96f-0ceb5eb54a04",
+            "N01": "3a19da56-1379-d64e-c6c5-c72ea4829888",
+            "O01": "3a19da56-1379-d887-1a3c-6f9cce90f90e",
+            "P01": "3a19da56-1379-e77d-0e65-7463b238a3b9",
+            "Q01": "3a19da56-1379-edf6-1472-802ddb628774",
+            "R01": "3a19da56-1379-f281-0273-e0ef78f0fd97",
+            "S01": "3a19da56-1379-f924-7f68-df1fa51489f4",
+            "T01": "3a19da56-1379-ff7c-1745-07e200b44ce2"
+        }
+    },
+    "配液站内试剂仓库": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19da43-57b5-294f-d663-154a1cc32270",
+            "B01": "3a19da43-57b5-7394-5f49-54efe2c9bef2",
+            "C01": "3a19da43-57b5-5e75-552f-8dbd0ad1075f",
+            "A02": "3a19da43-57b5-8441-db94-b4d3875a4b6c",
+            "B02": "3a19da43-57b5-3e41-c181-5119dddaf50c",
+            "C02": "3a19da43-57b5-269b-282d-fba61fe8ce96",
+            "A03": "3a19da43-57b5-7c1e-d02e-c40e8c33f8a1",
+            "B03": "3a19da43-57b5-659f-621f-1dcf3f640363",
+            "C03": "3a19da43-57b5-855a-6e71-f398e376dee1",
+        }
+    },
+    "试剂替换仓库": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19da51-8f4e-30f3-ea08-4f8498e9b097",
+            "B01": "3a19da51-8f4e-1da7-beb0-80a4a01e67a8",
+            "C01": "3a19da51-8f4e-337d-2675-bfac46880b06",
+            "D01": "3a19da51-8f4e-e514-b92c-9c44dc5e489d",
+            "E01": "3a19da51-8f4e-22d1-dd5b-9774ddc80402",
+            "F01": "3a19da51-8f4e-273a-4871-dff41c29bfd9",
+            "G01": "3a19da51-8f4e-b32f-454f-74bc1a665653",
+            "H01": "3a19da51-8f4e-8c93-68c9-0b4382320f59",
+            "I01": "3a19da51-8f4e-360c-0149-291b47c6089b",
+            "J01": "3a19da51-8f4e-4152-9bca-8d64df8c1af0"
+        }
+    },
+    "自动堆栈-左": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+            "A02": "3a19debc-84b5-033b-b31f-6b87f7c2bf52",
+            "B01": "3a19debc-84b5-3924-172f-719ab01b125c",
+            "B02": "3a19debc-84b5-aad8-70c6-b8c6bb2d8750"
+        }
+    },
+    "自动堆栈-右": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19debe-5200-7df2-1dd9-7d202f158864",
+            "A02": "3a19debe-5200-573b-6120-8b51f50e1e50",
+            "B01": "3a19debe-5200-7cd8-7666-851b0a97e309",
+            "B02": "3a19debe-5200-e6d3-96a3-baa6e3d5e484"
+        }
+    },
+    "手动堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
+            "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe",
+            "A03": "3a19deae-2c7a-5876-c454-6b7e224ca927",
+            "B01": "3a19deae-2c7a-2426-6d71-e9de3cb158b1",
+            "B02": "3a19deae-2c7a-79b0-5e44-efaafd1e4cf3",
+            "B03": "3a19deae-2c7a-b9eb-f4e3-e308e0cf839a",
+            "C01": "3a19deae-2c7a-32bc-768e-556647e292f3",
+            "C02": "3a19deae-2c7a-e97a-8484-f5a4599447c4",
+            "C03": "3a19deae-2c7a-3056-6504-10dc73fbc276",
+            "D01": "3a19deae-2c7a-ffad-875e-8c4cda61d440",
+            "D02": "3a19deae-2c7a-61be-601c-b6fb5610499a",
+            "D03": "3a19deae-2c7a-c0f7-05a7-e3fe2491e560",
+            "E01": "3a19deae-2c7a-a6f4-edd1-b436a7576363",
+            "E02": "3a19deae-2c7a-4367-96dd-1ca2186f4910",
+            "E03": "3a19deae-2c7a-b163-2219-23df15200311",
+            "F01": "3a19deae-2c7a-d594-fd6a-0d20de3c7c4a",
+            "F02": "3a19deae-2c7a-a194-ea63-8b342b8d8679",
+            "F03": "3a19deae-2c7a-f7c4-12bd-425799425698",
+            "G01": "3a19deae-2c7a-0b56-72f1-8ab86e53b955",
+            "G02": "3a19deae-2c7a-204e-95ed-1f1950f28343",
+            "G03": "3a19deae-2c7a-392b-62f1-4907c66343f8",
+            "H01": "3a19deae-2c7a-5602-e876-d27aca4e3201",
+            "H02": "3a19deae-2c7a-f15c-70e0-25b58a8c9702",
+            "H03": "3a19deae-2c7a-780b-8965-2e1345f7e834",
+            "I01": "3a19deae-2c7a-8849-e172-07de14ede928",
+            "I02": "3a19deae-2c7a-4772-a37f-ff99270bafc0",
+            "I03": "3a19deae-2c7a-cce7-6e4a-25ea4a2068c4",
+            "J01": "3a19deae-2c7a-1848-de92-b5d5ed054cc6",
+            "J02": "3a19deae-2c7a-1d45-b4f8-6f866530e205",
+            "J03": "3a19deae-2c7a-f237-89d9-8fe19025dee9"
+        }
+    },
+    "4号手套箱内部堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1baa20-a7b1-c665-8b9c-d8099d07d2f6",
+            "A02": "3a1baa20-a7b1-93a7-c988-f9c8ad6c58c9",
+            "A03": "3a1baa20-a7b1-00ee-f751-da9b20b6c464",
+            "A04": "3a1baa20-a7b1-4712-c37b-0b5b658ef7b9",
+            "B01": "3a1baa20-a7b1-9847-fc9c-96d604cd1a8e",
+            "B02": "3a1baa20-a7b1-4ae9-e604-0601db06249c",
+            "B03": "3a1baa20-a7b1-8329-ea75-81ca559d9ce1",
+            "B04": "3a1baa20-a7b1-89c5-d96f-36e98a8f7268",
+            "C01": "3a1baa20-a7b1-32ec-39e6-8044733839d6",
+            "C02": "3a1baa20-a7b1-b573-e426-4c86040348b2",
+            "C03": "3a1baa20-a7b1-cca7-781e-0522b729bf5d",
+            "C04": "3a1baa20-a7b1-7c98-5fd9-5855355ae4b3"
+        }
+    },
+    "大分液瓶堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19da3d-4f3d-bcac-2932-7542041e10e0",
+            "A02": "3a19da3d-4f3d-4d75-38ac-fb58ad0687c3",
+            "A03": "3a19da3d-4f3d-b25e-f2b1-85342a5b7eae",
+            "B01": "3a19da3d-4f3d-fd3e-058a-2733a0925767",
+            "B02": "3a19da3d-4f3d-37bd-a944-c391ad56857f",
+            "B03": "3a19da3d-4f3d-e353-7862-c6d1d4bc667f",
+            "C01": "3a19da3d-4f3d-9519-5da7-76179c958e70",
+            "C02": "3a19da3d-4f3d-b586-d7ed-9ec244f6f937",
+            "C03": "3a19da3d-4f3d-5061-249b-35dfef732811"
+        }
+    },
+    "小分液瓶堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "C03": "3a19da40-55bf-8943-d20d-a8b3ea0d16c0"
+        }
+    },
+    "站内Tip头盒堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a19deab-d5cc-be1e-5c37-4e9e5a664388",
+            "A02": "3a19deab-d5cc-b394-8141-27cb3853e8ea",
+            "B01": "3a19deab-d5cc-4dca-596e-ca7414d5f501",
+            "B02": "3a19deab-d5cc-9bc0-442b-12d9d59aa62a",
+            "C01": "3a19deab-d5cc-2eaf-b6a4-f0d54e4f1246",
+            "C02": "3a19deab-d5cc-d9f4-25df-b8018c372bc7"
+        }
+    },
+    "配液站内配液大板仓库(无需提前上料)": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1a21dc-06af-3915-9cb9-80a9dc42f386"
+        }
+    },
+    "配液站内配液小板仓库(无需以前入料)": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1a21de-8e8b-7938-2d06-858b36c10e31"
+        }
+    },
+    "移液站内大瓶板仓库(无需提前如料)": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1a224c-c727-fa62-1f2b-0037a84b9fca"
+        }
+    },
+    "移液站内小瓶板仓库(无需提前入料)": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb"
+        }
+    },
+    "适配器位仓库": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1abd46-18fe-1f56-6ced-a1f7fe08e36c"
+        }
+    },
+    "1号2号手套箱交接堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1baa49-7f77-35aa-60b1-e55a45d065fa"
+        }
+    },
+    "2号手套箱内部堆栈": {
+        "uuid": "",
+        "site_uuids": {
+            "A01": "3a1baa4b-393e-9f86-3921-7a18b0a8e371",
+            "A02": "3a1baa4b-393e-9425-928b-ee0f6f679d44",
+            "A03": "3a1baa4b-393e-0baf-632b-59dfdc931a3a",
+            "B01": "3a1baa4b-393e-f8aa-c8a9-956f3132f05c",
+            "B02": "3a1baa4b-393e-ef05-42f6-53f4c6e89d70",
+            "B03": "3a1baa4b-393e-c07b-a924-a9f0dfda9711",
+            "C01": "3a1baa4b-393e-4c2b-821a-16a7fe025c48",
+            "C02": "3a1baa4b-393e-2eaf-61a1-9063c832d5a2",
+            "C03": "3a1baa4b-393e-034e-8e28-8626d934a85f"
+        }
+    }
+    
 }
 
 # 物料类型配置
-MATERIAL_TYPE_IDS = {
-    "样品板": "",
-    "样品": "",
-    "烧杯": ""
-}
-
 MATERIAL_TYPE_MAPPINGS = {
-    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
-    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
-    "样品板": "BIOYOND_PolymerStation_6VialCarrier",
+    "100ml液体": ("YB_100ml_yeti", "d37166b3-ecaa-481e-bd84-3032b795ba07"),
+    "液": ("YB_ye", "3a190ca1-2add-2b23-f8e1-bbd348b7f790"),
+    "高粘液": ("YB_gaonianye", "abe8df30-563d-43d2-85e0-cabec59ddc16"),
+    "加样头(大)": ("YB_jia_yang_tou_da_Carrier", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "加样头(大)板": ("YB_jia_yang_tou_da", "a8e714ae-2a4e-4eb9-9614-e4c140ec3f16"),
+    "5ml分液瓶板": ("YB_5ml_fenyepingban", "3a192fa4-007d-ec7b-456e-2a8be7a13f23"),
+    "5ml分液瓶": ("YB_5ml_fenyeping", "3a192c2a-ebb7-58a1-480d-8b3863bf74f4"),
+    "20ml分液瓶板": ("YB_20ml_fenyepingban", "3a192fa4-47db-3449-162a-eaf8aba57e27"),
+    "20ml分液瓶": ("YB_20ml_fenyeping", "3a192c2b-19e8-f0a3-035e-041ca8ca1035"),
+    "配液瓶(小)板": ("YB_peiyepingxiaoban", "3a190c8b-3284-af78-d29f-9a69463ad047"),
+    "配液瓶(小)": ("YB_pei_ye_xiao_Bottle", "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"),
+    "配液瓶(大)板": ("YB_peiyepingdaban", "53e50377-32dc-4781-b3c0-5ce45bc7dc27"),
+    "配液瓶(大)": ("YB_pei_ye_da_Bottle", "19c52ad1-51c5-494f-8854-576f4ca9c6ca"),
+    "适配器块": ("YB_shi_pei_qi_kuai", "efc3bb32-d504-4890-91c0-b64ed3ac80cf"),
+    "枪头盒": ("YB_qiang_tou_he", "3a192c2e-20f3-a44a-0334-c8301839d0b3"),
+    "枪头": ("YB_qiang_tou", "b6196971-1050-46da-9927-333e8dea062d"),
 }
 
-# 步骤参数配置（各工作流的步骤UUID）
-WORKFLOW_STEP_IDS = {
-    "reactor_taken_in": {
-        "config": ""
+SOLID_LIQUID_MAPPINGS = {
+    # 固体
+    "LiDFOB": {
+        "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
+        "code": "",
+        "barCode": "",
+        "name": "LiDFOB",
+        "unit": "g",
+        "parameters": "",
+        "quantity": "2",
+        "warningQuantity": "1",
+        "details": []
     },
-    "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": ""
-    }
+    # "LiPF6": {
+    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
+    #     "code": "",
+    #     "barCode": "",
+    #     "name": "LiPF6",
+    #     "unit": "g",
+    #     "parameters": "",
+    #     "quantity": 2,
+    #     "warningQuantity": 1,
+    #     "details": []
+    # },
+    # "LiFSI": {
+    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
+    #     "code": "",
+    #     "barCode": "",
+    #     "name": "LiFSI",
+    #     "unit": "g",
+    #     "parameters": "",
+    #     "quantity": 2,
+    #     "warningQuantity": 1,
+    #     "details": []
+    # },
+    # "DTC": {
+    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
+    #     "code": "",
+    #     "barCode": "",
+    #     "name": "DTC",
+    #     "unit": "g",
+    #     "parameters": "",
+    #     "quantity": 2,
+    #     "warningQuantity": 1,
+    #     "details": []
+    # },
+    # "LiPO2F2": {
+    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
+    #     "code": "",
+    #     "barCode": "",
+    #     "name": "LiPO2F2",
+    #     "unit": "g",
+    #     "parameters": "",
+    #     "quantity": 2,
+    #     "warningQuantity": 1,
+    #     "details": []
+    # },
+    # 液体
+    # "SA": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "EC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "VC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "AND": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "HTCN": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "DENE": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "TMSP": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "TMSB": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "EP": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "DEC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "EMC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "SN": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "DMC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    # "FEC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
 }
+
+WORKFLOW_MAPPINGS = {}
+
+LOCATION_MAPPING = {}

unilabos/devices/workstation/bioyond_studio/experiment.py

@@ -1,203 +1,205 @@
-# experiment_workflow.py
 """
 实验流程主程序
 """
 
 import json
-from bioyond_rpc import BioyondV1RPC
-from config import API_CONFIG, WORKFLOW_MAPPINGS
+from unilabos.devices.workstation.bioyond_studio.reaction_station import BioyondReactionStation
+from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG, WORKFLOW_MAPPINGS, DECK_CONFIG, MATERIAL_TYPE_MAPPINGS
 
 
 def run_experiment():
     """运行实验流程"""
-    
+
     # 初始化Bioyond客户端
     config = {
         **API_CONFIG,
-        "workflow_mappings": WORKFLOW_MAPPINGS
+        "workflow_mappings": WORKFLOW_MAPPINGS,
+        "material_type_mappings": MATERIAL_TYPE_MAPPINGS
     }
-    
-    Bioyond = BioyondV1RPC(config)
-    
+
+    # 创建BioyondReactionStation实例，传入deck配置
+    Bioyond = BioyondReactionStation(
+        config=config,
+        deck=DECK_CONFIG
+    )
+
     print("\n============= 多工作流参数测试（简化接口+材料缓存）=============")
-    
+
     # 显示可用的材料名称（前20个）
-    available_materials = Bioyond.get_available_materials()
+    available_materials = Bioyond.hardware_interface.get_available_materials()
     print(f"可用材料名称（前20个）: {available_materials[:20]}")
     print(f"总共有 {len(available_materials)} 个材料可用\n")
-    
+
     # 1. 反应器放入
     print("1. 添加反应器放入工作流，带参数...")
     Bioyond.reactor_taken_in(
-        assign_material_name="BTDA-DD", 
-        cutoff="10000", 
+        assign_material_name="BTDA-DD",
+        cutoff="10000",
         temperature="-10"
     )
-    
+
     # 2. 液体投料-烧杯 (第一个)
     print("2. 添加液体投料-烧杯，带参数...")
     Bioyond.liquid_feeding_beaker(
-        volume="34768.7", 
+        volume="34768.7",
         assign_material_name="ODA",
-        time="0", 
-        torque_variation="1", 
-        titrationType="1", 
+        time="0",
+        torque_variation="1",
+        titration_type="1",
         temperature=-10
     )
-    
+
     # 3. 液体投料-烧杯 (第二个)
     print("3. 添加液体投料-烧杯，带参数...")
     Bioyond.liquid_feeding_beaker(
-        volume="34080.9", 
+        volume="34080.9",
         assign_material_name="MPDA",
-        time="5", 
-        torque_variation="2", 
-        titrationType="1", 
+        time="5",
+        torque_variation="2",
+        titration_type="1",
         temperature=0
     )
-    
+
     # 4. 液体投料-小瓶非滴定
     print("4. 添加液体投料-小瓶非滴定，带参数...")
     Bioyond.liquid_feeding_vials_non_titration(
-        volumeFormula="639.5", 
-        assign_material_name="SIDA", 
-        titration_type="1", 
-        time="0", 
-        torque_variation="1", 
+        volume_formula="639.5",
+        assign_material_name="SIDA",
+        titration_type="1",
+        time="0",
+        torque_variation="1",
         temperature=-10
     )
-    
+
     # 5. 液体投料溶剂
     print("5. 添加液体投料溶剂，带参数...")
     Bioyond.liquid_feeding_solvents(
         assign_material_name="NMP",
-        volume="19000", 
-        titration_type="1", 
-        time="5", 
-        torque_variation="2", 
+        volume="19000",
+        titration_type="1",
+        time="5",
+        torque_variation="2",
         temperature=-10
     )
-    
+
     # 6-8. 固体进料小瓶 (三个)
     print("6. 添加固体进料小瓶，带参数...")
     Bioyond.solid_feeding_vials(
-        material_id="3", 
-        time="180", 
+        material_id="3",
+        time="180",
         torque_variation="2",
-        assign_material_name="BTDA-1", 
+        assign_material_name="BTDA1",
         temperature=-10.00
     )
-    
+
     print("7. 添加固体进料小瓶，带参数...")
     Bioyond.solid_feeding_vials(
-        material_id="3", 
-        time="180", 
+        material_id="3",
+        time="180",
         torque_variation="2",
-        assign_material_name="BTDA-2", 
+        assign_material_name="BTDA2",
         temperature=25.00
     )
-    
+
     print("8. 添加固体进料小瓶，带参数...")
     Bioyond.solid_feeding_vials(
-        material_id="3", 
-        time="480", 
+        material_id="3",
+        time="480",
         torque_variation="2",
-        assign_material_name="BTDA-3", 
+        assign_material_name="BTDA3",
         temperature=25.00
     )
-    
+
     # 液体投料滴定（第一个）
     print("9. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="1000", 
+        volume_formula="{{6-0-5}}+{{7-0-5}}+{{8-0-5}}",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
-    
+
     # 液体投料滴定（第二个）
     print("10. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="500", 
+        volume_formula="500",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
 
     # 液体投料滴定（第三个）
     print("11. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="500", 
+        volume_formula="500",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
-    
+
     print("12. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="500", 
+        volume_formula="500",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
-    
+
     print("13. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="500", 
+        volume_formula="500",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
-    
+
     print("14. 添加液体投料滴定，带参数...")  # ODPA
     Bioyond.liquid_feeding_titration(
-        volume_formula="500", 
+        volume_formula="500",
         assign_material_name="BTDA-DD",
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature="25.00"
     )
 
-
-
     print("15. 添加液体投料溶剂，带参数...")
     Bioyond.liquid_feeding_solvents(
         assign_material_name="PGME",
-        volume="16894.6", 
-        titration_type="1", 
-        time="360", 
-        torque_variation="2", 
+        volume="16894.6",
+        titration_type="1",
+        time="360",
+        torque_variation="2",
         temperature=25.00
     )
-    
+
     # 16. 反应器取出
     print("16. 添加反应器取出工作流...")
     Bioyond.reactor_taken_out()
-    
+
     # 显示当前工作流序列
     sequence = Bioyond.get_workflow_sequence()
     print("\n当前工作流执行顺序:")
     print(sequence)
-    
+
     # 执行process_and_execute_workflow，合并工作流并创建任务
     print("\n4. 执行process_and_execute_workflow...")
-    
+
     result = Bioyond.process_and_execute_workflow(
-        workflow_name="test3_86", 
-        task_name="实验3_86"
+        workflow_name="test3",
+        task_name="实验3"
     )
-    
+
     # 显示执行结果
     print("\n5. 执行结果:")
     if isinstance(result, str):
@@ -205,9 +207,9 @@ def run_experiment():
             result_dict = json.loads(result)
             if result_dict.get("success"):
                 print("任务创建成功!")
-                print(f"- 工作流: {result_dict.get('workflow', {}).get('name')}")
-                print(f"- 工作流ID: {result_dict.get('workflow', {}).get('id')}")
-                print(f"- 任务结果: {result_dict.get('task')}")
+                # print(f"- 工作流: {result_dict.get('workflow', {}).get('name')}")
+                # print(f"- 工作流ID: {result_dict.get('workflow', {}).get('id')}")
+                # print(f"- 任务结果: {result_dict.get('task')}")
             else:
                 print(f"任务创建失败: {result_dict.get('error')}")
         except:
@@ -220,179 +222,179 @@ def run_experiment():
             print(f"- 任务结果: {result.get('task')}")
         else:
             print(f"任务创建失败: {result.get('error')}")
-    
+
     # 可选：启动调度器
     # Bioyond.scheduler_start()
-    
+
     return Bioyond
 
 
-def prepare_materials(bioyond):
-    """准备实验材料（可选）"""
-    
-    # 样品板材料数据定义
-    material_data_yp_1 = {
-        "typeId": "3a142339-80de-8f25-6093-1b1b1b6c322e",
-        "name": "样品板-1",
-        "unit": "个",
-        "quantity": 1,
-        "details": [
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BPDA-DD-1",
-                "quantity": 1,
-                "x": 1,
-                "y": 1,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "PEPA",
-                "quantity": 1,
-                "x": 1,
-                "y": 2,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BPDA-DD-2",
-                "quantity": 1,
-                "x": 1,
-                "y": 3,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BPDA-1",
-                "quantity": 1,
-                "x": 2,
-                "y": 1,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "PMDA",
-                "quantity": 1,
-                "x": 2,
-                "y": 2,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BPDA-2",
-                "quantity": 1,
-                "x": 2,
-                "y": 3,
-                "Parameters": "{\"molecular\": 1}"
-            }
-        ],
-        "Parameters": "{}"
-    }
-    
-    material_data_yp_2 = {
-        "typeId": "3a142339-80de-8f25-6093-1b1b1b6c322e",
-        "name": "样品板-2",
-        "unit": "个",
-        "quantity": 1,
-        "details": [
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BPDA-DD",
-                "quantity": 1,
-                "x": 1,
-                "y": 1,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "SIDA",
-                "quantity": 1,
-                "x": 1,
-                "y": 2,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BTDA-1",
-                "quantity": 1,
-                "x": 2,
-                "y": 1,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BTDA-2",
-                "quantity": 1,
-                "x": 2,
-                "y": 2,
-                "Parameters": "{\"molecular\": 1}"
-            },
-            {
-                "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
-                "name": "BTDA-3",
-                "quantity": 1,
-                "x": 2,
-                "y": 3,
-                "Parameters": "{\"molecular\": 1}"
-            }
-        ],
-        "Parameters": "{}"
-    }
-    
-    # 烧杯材料数据定义
-    beaker_materials = [
-        {
-            "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
-            "name": "PDA-1",
-            "unit": "微升",
-            "quantity": 1,
-            "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
-        },
-        {
-            "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
-            "name": "TFDB",
-            "unit": "微升",
-            "quantity": 1,
-            "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
-        },
-        {
-            "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
-            "name": "ODA",
-            "unit": "微升",
-            "quantity": 1,
-            "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
-        },
-        {
-            "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
-            "name": "MPDA",
-            "unit": "微升",
-            "quantity": 1,
-            "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
-        },
-        {
-            "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
-            "name": "PDA-2",
-            "unit": "微升",
-            "quantity": 1,
-            "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
-        }
-    ]
-    
-    # 如果需要，可以在这里调用add_material方法添加材料
-    # 例如:
-    # result = bioyond.add_material(json.dumps(material_data_yp_1))
-    # print(f"添加材料结果: {result}")
-    
-    return {
-        "sample_plates": [material_data_yp_1, material_data_yp_2],
-        "beakers": beaker_materials
-    }
+# def prepare_materials(bioyond):
+#     """准备实验材料（可选）"""
+
+#     # 样品板材料数据定义
+#     material_data_yp_1 = {
+#         "typeId": "3a142339-80de-8f25-6093-1b1b1b6c322e",
+#         "name": "样品板-1",
+#         "unit": "个",
+#         "quantity": 1,
+#         "details": [
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BPDA-DD-1",
+#                 "quantity": 1,
+#                 "x": 1,
+#                 "y": 1,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "PEPA",
+#                 "quantity": 1,
+#                 "x": 1,
+#                 "y": 2,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BPDA-DD-2",
+#                 "quantity": 1,
+#                 "x": 1,
+#                 "y": 3,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BPDA-1",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 1,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "PMDA",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 2,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BPDA-2",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 3,
+#                 "Parameters": "{\"molecular\": 1}"
+#             }
+#         ],
+#         "Parameters": "{}"
+#     }
+
+#     material_data_yp_2 = {
+#         "typeId": "3a142339-80de-8f25-6093-1b1b1b6c322e",
+#         "name": "样品板-2",
+#         "unit": "个",
+#         "quantity": 1,
+#         "details": [
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BPDA-DD",
+#                 "quantity": 1,
+#                 "x": 1,
+#                 "y": 1,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "SIDA",
+#                 "quantity": 1,
+#                 "x": 1,
+#                 "y": 2,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BTDA-1",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 1,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BTDA-2",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 2,
+#                 "Parameters": "{\"molecular\": 1}"
+#             },
+#             {
+#                 "typeId": "3a14233a-84a3-088d-6676-7cb4acd57c64",
+#                 "name": "BTDA-3",
+#                 "quantity": 1,
+#                 "x": 2,
+#                 "y": 3,
+#                 "Parameters": "{\"molecular\": 1}"
+#             }
+#         ],
+#         "Parameters": "{}"
+#     }
+
+#     # 烧杯材料数据定义
+#     beaker_materials = [
+#         {
+#             "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
+#             "name": "PDA-1",
+#             "unit": "微升",
+#             "quantity": 1,
+#             "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
+#         },
+#         {
+#             "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
+#             "name": "TFDB",
+#             "unit": "微升",
+#             "quantity": 1,
+#             "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
+#         },
+#         {
+#             "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
+#             "name": "ODA",
+#             "unit": "微升",
+#             "quantity": 1,
+#             "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
+#         },
+#         {
+#             "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
+#             "name": "MPDA",
+#             "unit": "微升",
+#             "quantity": 1,
+#             "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
+#         },
+#         {
+#             "typeId": "3a14233b-f0a9-ba84-eaa9-0d4718b361b6",
+#             "name": "PDA-2",
+#             "unit": "微升",
+#             "quantity": 1,
+#             "parameters": "{\"DeviceMaterialType\":\"NMP\"}"
+#         }
+#     ]
+
+#     # 如果需要，可以在这里调用add_material方法添加材料
+#     # 例如:
+#     # result = bioyond.add_material(json.dumps(material_data_yp_1))
+#     # print(f"添加材料结果: {result}")
+
+#     return {
+#         "sample_plates": [material_data_yp_1, material_data_yp_2],
+#         "beakers": beaker_materials
+#     }
 
 
 if __name__ == "__main__":
     # 运行主实验流程
     bioyond_client = run_experiment()
-    
+
     # 可选：准备材料数据
     # materials = prepare_materials(bioyond_client)
     # print(f"\n准备的材料数据: {materials}")

unilabos/devices/workstation/bioyond_studio/reaction_station.py

@@ -0,0 +1,783 @@
+import json
+import requests
+from typing import List, Dict, Any
+from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
+from unilabos.devices.workstation.bioyond_studio.config import (
+    WORKFLOW_STEP_IDS,
+    WORKFLOW_TO_SECTION_MAP,
+    ACTION_NAMES
+)
+from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
+
+
+class BioyondReactionStation(BioyondWorkstation):
+    """Bioyond反应站类
+
+    继承自BioyondWorkstation，提供反应站特定的业务方法
+    """
+
+    def __init__(self, config: dict = None, deck=None, protocol_type=None, **kwargs):
+        """初始化反应站
+
+        Args:
+            config: 配置字典，应包含workflow_mappings等配置
+            deck: Deck对象
+            protocol_type: 协议类型（由ROS系统传递，此处忽略）
+            **kwargs: 其他可能的参数
+        """
+        if deck is None and config:
+            deck = config.get('deck')
+
+        print(f"BioyondReactionStation初始化 - config包含workflow_mappings: {'workflow_mappings' in (config or {})}")
+        if config and 'workflow_mappings' in config:
+            print(f"workflow_mappings内容: {config['workflow_mappings']}")
+
+        super().__init__(bioyond_config=config, deck=deck)
+
+        print(f"BioyondReactionStation初始化完成 - workflow_mappings: {self.workflow_mappings}")
+        print(f"workflow_mappings长度: {len(self.workflow_mappings)}")
+
+    # ==================== 工作流方法 ====================
+
+    def reactor_taken_out(self):
+        """反应器取出"""
+        self.append_to_workflow_sequence('{"web_workflow_name": "reactor_taken_out"}')
+        reactor_taken_out_params = {"param_values": {}}
+        self.pending_task_params.append(reactor_taken_out_params)
+        print(f"成功添加反应器取出工作流")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def reactor_taken_in(
+        self,
+        assign_material_name: str,
+        cutoff: str = "900000",
+        temperature: float = -10.00
+    ):
+        """反应器放入
+
+        Args:
+            assign_material_name: 物料名称（不能为空）
+            cutoff: 粘度上限（需为有效数字字符串，默认 "900000"）
+            temperature: 温度设定（°C，范围：-50.00 至 100.00）
+
+        Returns:
+            str: JSON 字符串，格式为 {"suc": True}
+
+        Raises:
+            ValueError: 若物料名称无效或 cutoff 格式错误
+        """
+        if not assign_material_name:
+            raise ValueError("物料名称不能为空")
+        try:
+            float(cutoff)
+        except ValueError:
+            raise ValueError("cutoff 必须是有效的数字字符串")
+
+        self.append_to_workflow_sequence('{"web_workflow_name": "reactor_taken_in"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        step_id = WORKFLOW_STEP_IDS["reactor_taken_in"]["config"]
+        reactor_taken_in_params = {
+            "param_values": {
+                step_id: {
+                    ACTION_NAMES["reactor_taken_in"]["config"]: [
+                        {"m": 0, "n": 3, "Key": "cutoff", "Value": cutoff},
+                        {"m": 0, "n": 3, "Key": "assignMaterialName", "Value": material_id}
+                    ],
+                    ACTION_NAMES["reactor_taken_in"]["stirring"]: [
+                        {"m": 0, "n": 3, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(reactor_taken_in_params)
+        print(f"成功添加反应器放入参数: material={assign_material_name}->ID:{material_id}, cutoff={cutoff}, temp={temperature:.2f}")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def solid_feeding_vials(
+        self,
+        material_id: str,
+        time: str = "0",
+        torque_variation: int = 1,
+        assign_material_name: str = None,
+        temperature: float = 25.00
+    ):
+        """固体进料小瓶
+
+        Args:
+            material_id: 粉末类型ID，1=盐（21分钟），2=面粉（27分钟），3=BTDA（38分钟）
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            assign_material_name: 物料名称(用于获取试剂瓶位ID)
+            temperature: 温度设定(°C)
+        """
+        self.append_to_workflow_sequence('{"web_workflow_name": "Solid_feeding_vials"}')
+        material_id_m = self.hardware_interface._get_material_id_by_name(assign_material_name) if assign_material_name else None
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        feeding_step_id = WORKFLOW_STEP_IDS["solid_feeding_vials"]["feeding"]
+        observe_step_id = WORKFLOW_STEP_IDS["solid_feeding_vials"]["observe"]
+
+        solid_feeding_vials_params = {
+            "param_values": {
+                feeding_step_id: {
+                    ACTION_NAMES["solid_feeding_vials"]["feeding"]: [
+                        {"m": 0, "n": 3, "Key": "materialId", "Value": material_id},
+                        {"m": 0, "n": 3, "Key": "assignMaterialName", "Value": material_id_m} if material_id_m else {}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["solid_feeding_vials"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(solid_feeding_vials_params)
+        print(f"成功添加固体进料小瓶参数: material_id={material_id}, time={time}min, torque={torque_variation}, temp={temperature:.2f}°C")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def liquid_feeding_vials_non_titration(
+        self,
+        volume_formula: str,
+        assign_material_name: str,
+        titration_type: str = "1",
+        time: str = "0",
+        torque_variation: int = 1,
+        temperature: float = 25.00
+    ):
+        """液体进料小瓶(非滴定)
+
+        Args:
+            volume_formula: 分液公式(μL)
+            assign_material_name: 物料名称
+            titration_type: 是否滴定(1=否, 2=是)
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            temperature: 温度(°C)
+        """
+        self.append_to_workflow_sequence('{"web_workflow_name": "Liquid_feeding_vials(non-titration)"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_vials_non_titration"]["liquid"]
+        observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_vials_non_titration"]["observe"]
+
+        params = {
+            "param_values": {
+                liquid_step_id: {
+                    ACTION_NAMES["liquid_feeding_vials_non_titration"]["liquid"]: [
+                        {"m": 0, "n": 3, "Key": "volumeFormula", "Value": volume_formula},
+                        {"m": 0, "n": 3, "Key": "assignMaterialName", "Value": material_id},
+                        {"m": 0, "n": 3, "Key": "titrationType", "Value": titration_type}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["liquid_feeding_vials_non_titration"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(params)
+        print(f"成功添加液体进料小瓶(非滴定)参数: volume={volume_formula}μL, material={assign_material_name}->ID:{material_id}")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def liquid_feeding_solvents(
+        self,
+        assign_material_name: str,
+        volume: str = None,
+        solvents = None,
+        titration_type: str = "1",
+        time: str = "360",
+        torque_variation: int = 2,
+        temperature: float = 25.00
+    ):
+        """液体进料-溶剂
+
+        Args:
+            assign_material_name: 物料名称
+            volume: 分液量(μL),直接指定体积(可选,如果提供solvents则自动计算)
+            solvents: 溶剂信息的字典或JSON字符串(可选),格式如下:
+              {
+                  "additional_solvent": 33.55092503597727,  # 溶剂体积(mL)
+                  "total_liquid_volume": 48.00916988195499
+              }
+              如果提供solvents,则从中提取additional_solvent并转换为μL
+            titration_type: 是否滴定(1=否, 2=是)
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            temperature: 温度设定(°C)
+        """
+        # 处理 volume 参数:优先使用直接传入的 volume,否则从 solvents 中提取
+        if volume is None and solvents is not None:
+            # 参数类型转换:如果是字符串则解析为字典
+            if isinstance(solvents, str):
+                try:
+                    solvents = json.loads(solvents)
+                except json.JSONDecodeError as e:
+                    raise ValueError(f"solvents参数JSON解析失败: {str(e)}")
+
+            # 参数验证
+            if not isinstance(solvents, dict):
+                raise ValueError("solvents 必须是字典类型或有效的JSON字符串")
+
+            # 提取 additional_solvent 值
+            additional_solvent = solvents.get("additional_solvent")
+            if additional_solvent is None:
+                raise ValueError("solvents 中没有找到 additional_solvent 字段")
+
+            # 转换为微升(μL) - 从毫升(mL)转换
+            volume = str(float(additional_solvent) * 1000)
+        elif volume is None:
+            raise ValueError("必须提供 volume 或 solvents 参数之一")
+
+        self.append_to_workflow_sequence('{"web_workflow_name": "Liquid_feeding_solvents"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_solvents"]["liquid"]
+        observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_solvents"]["observe"]
+
+        params = {
+            "param_values": {
+                liquid_step_id: {
+                    ACTION_NAMES["liquid_feeding_solvents"]["liquid"]: [
+                        {"m": 0, "n": 1, "Key": "titrationType", "Value": titration_type},
+                        {"m": 0, "n": 1, "Key": "volume", "Value": volume},
+                        {"m": 0, "n": 1, "Key": "assignMaterialName", "Value": material_id}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["liquid_feeding_solvents"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(params)
+        print(f"成功添加液体进料溶剂参数: material={assign_material_name}->ID:{material_id}, volume={volume}μL")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def liquid_feeding_titration(
+        self,
+        volume_formula: str,
+        assign_material_name: str,
+        titration_type: str = "1",
+        time: str = "90",
+        torque_variation: int = 2,
+        temperature: float = 25.00
+    ):
+        """液体进料(滴定)
+
+        Args:
+            volume_formula: 分液公式(μL)
+            assign_material_name: 物料名称
+            titration_type: 是否滴定(1=否, 2=是)
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            temperature: 温度(°C)
+        """
+        self.append_to_workflow_sequence('{"web_workflow_name": "Liquid_feeding(titration)"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["liquid"]
+        observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["observe"]
+
+        params = {
+            "param_values": {
+                liquid_step_id: {
+                    ACTION_NAMES["liquid_feeding_titration"]["liquid"]: [
+                        {"m": 0, "n": 3, "Key": "volumeFormula", "Value": volume_formula},
+                        {"m": 0, "n": 3, "Key": "titrationType", "Value": titration_type},
+                        {"m": 0, "n": 3, "Key": "assignMaterialName", "Value": material_id}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["liquid_feeding_titration"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(params)
+        print(f"成功添加液体进料滴定参数: volume={volume_formula}μL, material={assign_material_name}->ID:{material_id}")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def liquid_feeding_beaker(
+        self,
+        volume: str = "35000",
+        assign_material_name: str = "BAPP",
+        time: str = "0",
+        torque_variation: int = 1,
+        titration_type: str = "1",
+        temperature: float = 25.00
+    ):
+        """液体进料烧杯
+
+        Args:
+            volume: 分液量(μL)
+            assign_material_name: 物料名称(试剂瓶位)
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            titration_type: 是否滴定(1=否, 2=是)
+            temperature: 温度设定(°C)
+        """
+        self.append_to_workflow_sequence('{"web_workflow_name": "liquid_feeding_beaker"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_beaker"]["liquid"]
+        observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_beaker"]["observe"]
+
+        params = {
+            "param_values": {
+                liquid_step_id: {
+                    ACTION_NAMES["liquid_feeding_beaker"]["liquid"]: [
+                        {"m": 0, "n": 2, "Key": "volume", "Value": volume},
+                        {"m": 0, "n": 2, "Key": "assignMaterialName", "Value": material_id},
+                        {"m": 0, "n": 2, "Key": "titrationType", "Value": titration_type}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["liquid_feeding_beaker"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(params)
+        print(f"成功添加液体进料烧杯参数: volume={volume}μL, material={assign_material_name}->ID:{material_id}")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    def drip_back(
+        self,
+        assign_material_name: str,
+        volume: str,
+        titration_type: str = "1",
+        time: str = "90",
+        torque_variation: int = 2,
+        temperature: float = 25.00
+    ):
+        """滴回去
+
+        Args:
+            assign_material_name: 物料名称(液体种类)
+            volume: 分液量(μL)
+            titration_type: 是否滴定(1=否, 2=是)
+            time: 观察时间(分钟)
+            torque_variation: 是否观察(int类型, 1=否, 2=是)
+            temperature: 温度(°C)
+        """
+        self.append_to_workflow_sequence('{"web_workflow_name": "drip_back"}')
+        material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
+        if material_id is None:
+            raise ValueError(f"无法找到物料 {assign_material_name} 的 ID")
+
+        if isinstance(temperature, str):
+            temperature = float(temperature)
+
+        liquid_step_id = WORKFLOW_STEP_IDS["drip_back"]["liquid"]
+        observe_step_id = WORKFLOW_STEP_IDS["drip_back"]["observe"]
+
+        params = {
+            "param_values": {
+                liquid_step_id: {
+                    ACTION_NAMES["drip_back"]["liquid"]: [
+                        {"m": 0, "n": 1, "Key": "titrationType", "Value": titration_type},
+                        {"m": 0, "n": 1, "Key": "assignMaterialName", "Value": material_id},
+                        {"m": 0, "n": 1, "Key": "volume", "Value": volume}
+                    ]
+                },
+                observe_step_id: {
+                    ACTION_NAMES["drip_back"]["observe"]: [
+                        {"m": 1, "n": 0, "Key": "time", "Value": time},
+                        {"m": 1, "n": 0, "Key": "torqueVariation", "Value": str(torque_variation)},
+                        {"m": 1, "n": 0, "Key": "temperature", "Value": f"{temperature:.2f}"}
+                    ]
+                }
+            }
+        }
+
+        self.pending_task_params.append(params)
+        print(f"成功添加滴回去参数: material={assign_material_name}->ID:{material_id}, volume={volume}μL")
+        print(f"当前队列长度: {len(self.pending_task_params)}")
+        return json.dumps({"suc": True})
+
+    # ==================== 工作流管理方法 ====================
+
+    def get_workflow_sequence(self) -> List[str]:
+        """获取当前工作流执行顺序
+
+        Returns:
+            工作流名称列表
+        """
+        id_to_name = {workflow_id: name for name, workflow_id in self.workflow_mappings.items()}
+        workflow_names = []
+        for workflow_id in self.workflow_sequence:
+            workflow_name = id_to_name.get(workflow_id, workflow_id)
+            workflow_names.append(workflow_name)
+        print(f"工作流序列: {workflow_names}")
+        return workflow_names
+
+    def workflow_step_query(self, workflow_id: str) -> dict:
+        """查询工作流步骤参数
+
+        Args:
+            workflow_id: 工作流ID
+
+        Returns:
+            工作流步骤参数字典
+        """
+        return self.hardware_interface.workflow_step_query(workflow_id)
+
+    def create_order(self, json_str: str) -> dict:
+        """创建订单
+
+        Args:
+            json_str: 订单参数的JSON字符串
+
+        Returns:
+            创建结果
+        """
+        return self.hardware_interface.create_order(json_str)
+
+    # ==================== 工作流执行核心方法 ====================
+
+    def process_web_workflows(self, web_workflow_json: str) -> List[Dict[str, str]]:
+        """处理网页工作流列表
+
+        Args:
+            web_workflow_json: JSON 格式的网页工作流列表
+
+        Returns:
+            List[Dict[str, str]]: 包含工作流 ID 和名称的字典列表
+        """
+        try:
+            web_workflow_data = json.loads(web_workflow_json)
+            web_workflow_list = web_workflow_data.get("web_workflow_list", [])
+            workflows_result = []
+            for name in web_workflow_list:
+                workflow_id = self.workflow_mappings.get(name, "")
+                if not workflow_id:
+                    print(f"警告：未找到工作流名称 {name} 对应的 ID")
+                    continue
+                workflows_result.append({"id": workflow_id, "name": name})
+            print(f"process_web_workflows 输出: {workflows_result}")
+            return workflows_result
+        except json.JSONDecodeError as e:
+            print(f"错误：无法解析 web_workflow_json: {e}")
+            return []
+        except Exception as e:
+            print(f"错误：处理工作流失败: {e}")
+            return []
+
+    def process_and_execute_workflow(self, workflow_name: str, task_name: str) -> dict:
+        """
+        一站式处理工作流程：解析网页工作流列表，合并工作流(带参数)，然后发布任务
+
+        Args:
+            workflow_name: 合并后的工作流名称
+            task_name: 任务名称
+
+        Returns:
+            任务创建结果
+        """
+        web_workflow_list = self.get_workflow_sequence()
+        print(f"\n{'='*60}")
+        print(f"📋 处理网页工作流列表: {web_workflow_list}")
+        print(f"{'='*60}")
+
+        web_workflow_json = json.dumps({"web_workflow_list": web_workflow_list})
+        workflows_result = self.process_web_workflows(web_workflow_json)
+
+        if not workflows_result:
+            return self._create_error_result("处理网页工作流列表失败", "process_web_workflows")
+
+        print(f"workflows_result 类型: {type(workflows_result)}")
+        print(f"workflows_result 内容: {workflows_result}")
+
+        workflows_with_params = self._build_workflows_with_parameters(workflows_result)
+
+        merge_data = {
+            "name": workflow_name,
+            "workflows": workflows_with_params
+        }
+
+        # print(f"\n🔄 合并工作流（带参数），名称: {workflow_name}")
+        merged_workflow = self.merge_workflow_with_parameters(json.dumps(merge_data))
+
+        if not merged_workflow:
+            return self._create_error_result("合并工作流失败", "merge_workflow_with_parameters")
+
+        workflow_id = merged_workflow.get("subWorkflows", [{}])[0].get("id", "")
+        # print(f"\n📤 使用工作流创建任务: {workflow_name} (ID: {workflow_id})")
+
+        order_params = [{
+            "orderCode": f"task_{self.hardware_interface.get_current_time_iso8601()}",
+            "orderName": task_name,
+            "workFlowId": workflow_id,
+            "borderNumber": 1,
+            "paramValues": {}
+        }]
+
+        result = self.create_order(json.dumps(order_params))
+
+        if not result:
+            return self._create_error_result("创建任务失败", "create_order")
+
+        # 清空工作流序列和参数，防止下次执行时累积重复
+        self.pending_task_params = []
+        self.clear_workflows()  # 清空工作流序列，避免重复累积
+
+        # print(f"\n✅ 任务创建成功: {result}")
+        # print(f"\n✅ 任务创建成功")
+        print(f"{'='*60}\n")
+        return json.dumps({"success": True, "result": result})
+
+    def _build_workflows_with_parameters(self, workflows_result: list) -> list:
+        """
+        构建带参数的工作流列表
+
+        Args:
+            workflows_result: 处理后的工作流列表（应为包含 id 和 name 的字典列表）
+
+        Returns:
+            符合新接口格式的工作流参数结构
+        """
+        workflows_with_params = []
+        total_params = 0
+        successful_params = 0
+        failed_params = []
+
+        for idx, workflow_info in enumerate(workflows_result):
+            if not isinstance(workflow_info, dict):
+                print(f"错误：workflows_result[{idx}] 不是字典，而是 {type(workflow_info)}: {workflow_info}")
+                continue
+            workflow_id = workflow_info.get("id")
+            if not workflow_id:
+                print(f"警告：workflows_result[{idx}] 缺少 'id' 键")
+                continue
+            workflow_name = workflow_info.get("name", "")
+            # print(f"\n🔧 处理工作流 [{idx}]: {workflow_name} (ID: {workflow_id})")
+
+            if idx >= len(self.pending_task_params):
+                # print(f"   ⚠️ 无对应参数，跳过")
+                workflows_with_params.append({"id": workflow_id})
+                continue
+
+            param_data = self.pending_task_params[idx]
+            param_values = param_data.get("param_values", {})
+            if not param_values:
+                # print(f"   ⚠️ 参数为空，跳过")
+                workflows_with_params.append({"id": workflow_id})
+                continue
+
+            step_parameters = {}
+            for step_id, actions_dict in param_values.items():
+                # print(f"   📍 步骤ID: {step_id}")
+                for action_name, param_list in actions_dict.items():
+                    # print(f"      🔹 模块: {action_name}, 参数数量: {len(param_list)}")
+                    if step_id not in step_parameters:
+                        step_parameters[step_id] = {}
+                    if action_name not in step_parameters[step_id]:
+                        step_parameters[step_id][action_name] = []
+                    for param_item in param_list:
+                        param_key = param_item.get("Key", "")
+                        param_value = param_item.get("Value", "")
+                        total_params += 1
+                        step_parameters[step_id][action_name].append({
+                            "Key": param_key,
+                            "DisplayValue": param_value,
+                            "Value": param_value
+                        })
+                        successful_params += 1
+                        # print(f"         ✓ {param_key} = {param_value}")
+
+            workflows_with_params.append({
+                "id": workflow_id,
+                "stepParameters": step_parameters
+            })
+
+        self._print_mapping_stats(total_params, successful_params, failed_params)
+        return workflows_with_params
+
+    def _print_mapping_stats(self, total: int, success: int, failed: list):
+        """打印参数映射统计"""
+        print(f"\n{'='*20} 参数映射统计 {'='*20}")
+        print(f"📊 总参数数量: {total}")
+        print(f"✅ 成功映射: {success}")
+        print(f"❌ 映射失败: {len(failed)}")
+        if not failed:
+            print("🎉 成功映射所有参数！")
+        else:
+            print(f"⚠️ 失败的参数: {', '.join(failed)}")
+        success_rate = (success/total*100) if total > 0 else 0
+        print(f"📈 映射成功率: {success_rate:.1f}%")
+        print("="*60)
+
+    def _create_error_result(self, error_msg: str, step: str) -> str:
+        """创建统一的错误返回格式"""
+        print(f"❌ {error_msg}")
+        return json.dumps({
+            "success": False,
+            "error": f"process_and_execute_workflow: {error_msg}",
+            "method": "process_and_execute_workflow",
+            "step": step
+        })
+
+    def merge_workflow_with_parameters(self, json_str: str) -> dict:
+        """
+        调用新接口：合并工作流并传递参数
+
+        Args:
+            json_str: JSON格式的字符串，包含:
+                - name: 工作流名称
+                - workflows: [{"id": "工作流ID", "stepParameters": {...}}]
+
+        Returns:
+            合并后的工作流信息
+        """
+        try:
+            data = json.loads(json_str)
+
+            # 在工作流名称后面添加时间戳，避免重复
+            if "name" in data and data["name"]:
+                timestamp = self.hardware_interface.get_current_time_iso8601().replace(":", "-").replace(".", "-")
+                original_name = data["name"]
+                data["name"] = f"{original_name}_{timestamp}"
+                print(f"🕒 工作流名称已添加时间戳: {original_name} -> {data['name']}")
+
+            request_data = {
+                "apiKey": API_CONFIG["api_key"],
+                "requestTime": self.hardware_interface.get_current_time_iso8601(),
+                "data": data
+            }
+            print(f"\n📤 发送合并请求:")
+            print(f"   工作流名称: {data.get('name')}")
+            print(f"   子工作流数量: {len(data.get('workflows', []))}")
+
+            # 打印完整的POST请求内容
+            print(f"\n🔍 POST请求详细内容:")
+            print(f"   URL: {self.hardware_interface.host}/api/lims/workflow/merge-workflow-with-parameters")
+            print(f"   Headers: {{'Content-Type': 'application/json'}}")
+            print(f"   Request Data:")
+            print(f"   {json.dumps(request_data, indent=4, ensure_ascii=False)}")
+            #
+            response = requests.post(
+                f"{self.hardware_interface.host}/api/lims/workflow/merge-workflow-with-parameters",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+
+            # # 打印响应详细内容
+            # print(f"\n📥 POST响应详细内容:")
+            # print(f"   状态码: {response.status_code}")
+            # print(f"   响应头: {dict(response.headers)}")
+            # print(f"   响应体: {response.text}")
+            # #
+            try:
+                result = response.json()
+                # #
+                # print(f"\n📋 解析后的响应JSON:")
+                # print(f"   {json.dumps(result, indent=4, ensure_ascii=False)}")
+                # #
+            except json.JSONDecodeError:
+                print(f"❌ 服务器返回非 JSON 格式响应: {response.text}")
+                return None
+
+            if result.get("code") == 1:
+                print(f"✅ 工作流合并成功（带参数）")
+                return result.get("data", {})
+            else:
+                error_msg = result.get('message', '未知错误')
+                print(f"❌ 工作流合并失败: {error_msg}")
+                return None
+
+        except requests.exceptions.Timeout:
+            print(f"❌ 合并工作流请求超时")
+            return None
+        except requests.exceptions.RequestException as e:
+            print(f"❌ 合并工作流网络异常: {str(e)}")
+            return None
+        except json.JSONDecodeError as e:
+            print(f"❌ 合并工作流响应解析失败: {str(e)}")
+            return None
+        except Exception as e:
+            print(f"❌ 合并工作流异常: {str(e)}")
+            return None
+
+    def _validate_and_refresh_workflow_if_needed(self, workflow_name: str) -> bool:
+        """验证工作流ID是否有效，如果无效则重新合并
+
+        Args:
+            workflow_name: 工作流名称
+
+        Returns:
+            bool: 验证或刷新是否成功
+        """
+        print(f"\n🔍 验证工作流ID有效性...")
+        if not self.workflow_sequence:
+            print(f"   ⚠️ 工作流序列为空，需要重新合并")
+            return False
+        first_workflow_id = self.workflow_sequence[0]
+        try:
+            structure = self.workflow_step_query(first_workflow_id)
+            if structure:
+                print(f"   ✅ 工作流ID有效")
+                return True
+            else:
+                print(f"   ⚠️ 工作流ID已过期，需要重新合并")
+                return False
+        except Exception as e:
+            print(f"   ❌ 工作流ID验证失败: {e}")
+            print(f"   💡 将重新合并工作流")
+            return False

unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py

@@ -0,0 +1,639 @@
+"""
+纽扣电池组装工作站物料类定义
+Button Battery Assembly Station Resource Classes
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, TypedDict, Union, cast
+
+from pylabrobot.resources.coordinate import Coordinate
+from pylabrobot.resources.container import Container
+from pylabrobot.resources.deck import Deck
+from pylabrobot.resources.itemized_resource import ItemizedResource
+from pylabrobot.resources.resource import Resource
+from pylabrobot.resources.resource_stack import ResourceStack
+from pylabrobot.resources.tip_rack import TipRack, TipSpot
+from pylabrobot.resources.trash import Trash
+from pylabrobot.resources.utils import create_ordered_items_2d
+
+from unilabos.resources.battery.magazine import MagazineHolder_4_Cathode, MagazineHolder_6_Cathode, MagazineHolder_6_Anode, MagazineHolder_6_Battery
+from unilabos.resources.battery.bottle_carriers import YIHUA_Electrolyte_12VialCarrier
+from unilabos.resources.battery.electrode_sheet import ElectrodeSheet
+
+
+
+# TODO: 这个应该只能放一个极片
+class MaterialHoleState(TypedDict):
+    diameter: int
+    depth: int
+    max_sheets: int
+    info: Optional[str]  # 附加信息
+
+class MaterialHole(Resource):
+    """料板洞位类"""
+    children: List[ElectrodeSheet] = []
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        category: str = "material_hole",
+        **kwargs
+    ):
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+        )
+        self._unilabos_state: MaterialHoleState = MaterialHoleState(
+            diameter=20,
+            depth=10,
+            max_sheets=1,
+            info=None
+        )
+
+    def get_all_sheet_info(self):
+        info_list = []
+        for sheet in self.children:
+            info_list.append(sheet._unilabos_state["info"])
+        return info_list
+    
+    #这个函数函数好像没用，一般不会集中赋值质量
+    def set_all_sheet_mass(self):
+        for sheet in self.children:
+            sheet._unilabos_state["mass"] = 0.5  # 示例：设置质量为0.5g
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+    #移动极片前先取出对象
+    def get_sheet_with_name(self, name: str) -> Optional[ElectrodeSheet]:
+        for sheet in self.children:
+            if sheet.name == name:
+                return sheet
+        return None
+
+    def has_electrode_sheet(self) -> bool:
+        """检查洞位是否有极片"""
+        return len(self.children) > 0
+
+    def assign_child_resource(
+        self,
+        resource: ElectrodeSheet,
+        location: Optional[Coordinate],
+        reassign: bool = True,
+    ):
+        """放置极片"""
+        # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题
+        #if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]:
+        #    raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}")
+        #if len(self.children) >= self._unilabos_state["max_sheets"]:
+        #    raise ValueError(f"洞位已满，无法放置更多极片")
+        super().assign_child_resource(resource, location, reassign)
+
+    # 根据children的编号取物料对象。
+    def get_electrode_sheet_info(self, index: int) -> ElectrodeSheet:
+        return self.children[index]
+
+
+class MaterialPlateState(TypedDict):
+    hole_spacing_x: float
+    hole_spacing_y: float
+    hole_diameter: float
+    info: Optional[str]  # 附加信息
+
+class MaterialPlate(ItemizedResource[MaterialHole]):
+    """料板类 - 4x4个洞位，每个洞位放1个极片"""
+    
+    children: List[MaterialHole]
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        ordered_items: Optional[Dict[str, MaterialHole]] = None,
+        ordering: Optional[OrderedDict[str, str]] = None,
+        category: str = "material_plate",
+        model: Optional[str] = None,
+        fill: bool = False
+    ):
+        """初始化料板
+
+        Args:
+            name: 料板名称
+            size_x: 长度 (mm)
+            size_y: 宽度 (mm)
+            size_z: 高度 (mm)
+            hole_diameter: 洞直径 (mm)
+            hole_depth: 洞深度 (mm)
+            hole_spacing_x: X方向洞位间距 (mm)
+            hole_spacing_y: Y方向洞位间距 (mm)
+            number: 编号
+            category: 类别
+            model: 型号
+        """
+        self._unilabos_state: MaterialPlateState = MaterialPlateState(
+            hole_spacing_x=24.0,
+            hole_spacing_y=24.0,
+            hole_diameter=20.0,
+            info="",
+        )
+        # 创建4x4的洞位
+        # TODO: 这里要改，对应不同形状
+        holes = create_ordered_items_2d(
+            klass=MaterialHole,
+            num_items_x=4,
+            num_items_y=4,
+            dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
+            dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
+            dz=size_z,
+            item_dx=self._unilabos_state["hole_spacing_x"],
+            item_dy=self._unilabos_state["hole_spacing_y"],
+            size_x = 16,
+            size_y = 16,
+            size_z = 16,
+        )
+        if fill:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=holes,
+                category=category,
+                model=model,
+            )
+        else:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=ordered_items,
+                ordering=ordering,
+                category=category,
+                model=model,
+            )
+
+    def update_locations(self):
+        # TODO:调多次相加
+        holes = create_ordered_items_2d(
+            klass=MaterialHole,
+            num_items_x=4,
+            num_items_y=4,
+            dx=(self._size_x - 3 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
+            dy=(self._size_y - 3 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
+            dz=self._size_z,
+            item_dx=self._unilabos_state["hole_spacing_x"],
+            item_dy=self._unilabos_state["hole_spacing_y"],
+            size_x = 1,
+            size_y = 1,
+            size_z = 1,
+        )
+        for item, original_item in zip(holes.items(), self.children):
+            original_item.location = item[1].location
+
+
+class PlateSlot(ResourceStack):
+    """板槽位类 - 1个槽上能堆放8个板，移板只能操作最上方的板"""
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        max_plates: int = 8,
+        category: str = "plate_slot",
+        model: Optional[str] = None
+    ):
+        """初始化板槽位
+
+        Args:
+            name: 槽位名称
+            max_plates: 最大板数量
+            category: 类别
+        """
+        super().__init__(
+            name=name,
+            direction="z",  # Z方向堆叠
+            resources=[],
+        )
+        self.max_plates = max_plates
+        self.category = category
+
+    def can_add_plate(self) -> bool:
+        """检查是否可以添加板"""
+        return len(self.children) < self.max_plates
+
+    def add_plate(self, plate: MaterialPlate) -> None:
+        """添加料板"""
+        if not self.can_add_plate():
+            raise ValueError(f"槽位 {self.name} 已满，无法添加更多板")
+        self.assign_child_resource(plate)
+
+    def get_top_plate(self) -> MaterialPlate:
+        """获取最上方的板"""
+        if len(self.children) == 0:
+            raise ValueError(f"槽位 {self.name} 为空")
+        return cast(MaterialPlate, self.get_top_item())
+
+    def take_top_plate(self) -> MaterialPlate:
+        """取出最上方的板"""
+        top_plate = self.get_top_plate()
+        self.unassign_child_resource(top_plate)
+        return top_plate
+
+    def can_access_for_picking(self) -> bool:
+        """检查是否可以进行取料操作（只有最上方的板能进行取料操作）"""
+        return len(self.children) > 0
+
+    def serialize(self) -> dict:
+        return {
+            **super().serialize(),
+            "max_plates": self.max_plates,
+        }
+
+
+#是一种类型注解，不用self
+class BatteryState(TypedDict):
+    """电池状态字典"""
+    diameter: float
+    height: float
+    assembly_pressure: float
+    electrolyte_volume: float
+    electrolyte_name: str
+
+class Battery(Resource):
+    """电池类 - 可容纳极片"""
+    children: List[ElectrodeSheet] = []
+
+    def __init__(
+        self,
+        name: str,
+        size_x=1,
+        size_y=1,
+        size_z=1,
+        category: str = "battery",
+    ):
+        """初始化电池
+
+        Args:
+            name: 电池名称
+            diameter: 直径 (mm)
+            height: 高度 (mm)
+            max_volume: 最大容量 (μL)
+            barcode: 二维码编号
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=1,
+            size_y=1,
+            size_z=1,
+            category=category,
+        )
+        self._unilabos_state: BatteryState = BatteryState(
+                                 diameter = 1.0,
+                                 height = 1.0,
+                                 assembly_pressure = 1.0,
+                                 electrolyte_volume = 1.0,
+                                 electrolyte_name = "DP001"
+                                 )
+
+    def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool:
+        to_add_name = bottle._unilabos_state["electrolyte_name"]
+        if bottle.aspirate_electrolyte(10):
+            if self.add_electrolyte(to_add_name, 10):
+                pass
+            else:
+                bottle._unilabos_state["electrolyte_volume"] += 10
+
+    def set_electrolyte(self, name: str, volume: float) -> None:
+        """设置电解液信息"""
+        self._unilabos_state["electrolyte_name"] = name
+        self._unilabos_state["electrolyte_volume"] = volume
+    #这个应该没用，不会有加了后再加的事情
+    def add_electrolyte(self, name: str, volume: float) -> bool:
+        """添加电解液信息"""
+        if name != self._unilabos_state["electrolyte_name"]:
+            return False
+        self._unilabos_state["electrolyte_volume"] += volume
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+# 电解液作为属性放进去
+
+class BatteryPressSlotState(TypedDict):
+    """电池状态字典"""
+    diameter: float =20.0
+    depth: float = 4.0
+
+class BatteryPressSlot(Resource):
+    """电池压制槽类 - 设备，可容纳一个电池"""
+    children: List[Battery] = []
+
+    def __init__(
+        self,
+        name: str = "BatteryPressSlot",
+        category: str = "battery_press_slot",
+    ):
+        """初始化电池压制槽
+
+        Args:
+            name: 压制槽名称
+            diameter: 直径 (mm)
+            depth: 深度 (mm)
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=10,
+            size_y=12,
+            size_z=13,
+            category=category,
+        )
+        self._unilabos_state: BatteryPressSlotState = BatteryPressSlotState()
+
+    def has_battery(self) -> bool:
+        """检查是否有电池"""
+        return len(self.children) > 0
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+    
+    def assign_child_resource(
+        self,
+        resource: Battery,
+        location: Optional[Coordinate],
+        reassign: bool = True,
+    ):
+        """放置极片"""
+        # TODO: 让高京看下槽位只有一个电池时是否这么写。
+        if self.has_battery():
+            raise ValueError(f"槽位已含有一个电池，无法再放置其他电池")
+        super().assign_child_resource(resource, location, reassign)
+
+    # 根据children的编号取物料对象。
+    def get_battery_info(self, index: int) -> Battery:
+        return self.children[0]
+
+
+def TipBox64(
+        name: str,
+        size_x: float = 127.8,
+        size_y: float = 85.5,
+        size_z: float = 60.0,
+        category: str = "tip_rack",
+        model: Optional[str] = None,
+):
+    """64孔枪头盒类"""
+    from pylabrobot.resources.tip import Tip
+
+    # 创建12x8=96个枪头位
+    def make_tip():
+        return Tip(
+            has_filter=False,
+            total_tip_length=20.0,
+            maximal_volume=1000,  # 1mL
+            fitting_depth=8.0,
+        )
+
+    tip_spots = create_ordered_items_2d(
+        klass=TipSpot,
+        num_items_x=12,
+        num_items_y=8,
+        dx=8.0,
+        dy=8.0,
+        dz=0.0,
+        item_dx=9.0,
+        item_dy=9.0,
+        size_x=10,
+        size_y=10,
+        size_z=0.0,
+        make_tip=make_tip,
+    )
+    idx_available = list(range(0, 32)) + list(range(64, 96))
+    tip_spots_available = {k: v for i, (k, v) in enumerate(tip_spots.items()) if i in idx_available}
+    tip_rack = TipRack(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        # ordered_items=tip_spots_available,
+        ordered_items=tip_spots,
+        category=category,
+        model=model,
+        with_tips=False,
+    )
+    tip_rack.set_tip_state([True]*32 + [False]*32 + [True]*32)  # 前32和后32个有枪头，中间32个无枪头
+    return tip_rack
+
+
+class WasteTipBoxstate(TypedDict):
+    """"废枪头盒状态字典"""
+    max_tips: int = 100
+    tip_count: int = 0
+
+#枪头不是一次性的（同一溶液则反复使用），根据寄存器判断
+class WasteTipBox(Trash):
+    """废枪头盒类 - 100个枪头容量"""
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float = 127.8,
+        size_y: float = 85.5,
+        size_z: float = 60.0,
+        material_z_thickness=0,
+        max_volume=float("inf"),
+        category="trash",
+        model=None,
+        compute_volume_from_height=None,
+        compute_height_from_volume=None,
+    ):
+        """初始化废枪头盒
+
+        Args:
+            name: 废枪头盒名称
+            size_x: 长度 (mm)
+            size_y: 宽度 (mm)
+            size_z: 高度 (mm)
+            max_tips: 最大枪头容量
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+            model=model,
+        )
+        self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate()
+
+    def add_tip(self) -> None:
+        """添加废枪头"""
+        if self._unilabos_state["tip_count"] >= self._unilabos_state["max_tips"]:
+            raise ValueError(f"废枪头盒 {self.name} 已满")
+        self._unilabos_state["tip_count"] += 1
+
+    def get_tip_count(self) -> int:
+        """获取枪头数量"""
+        return self._unilabos_state["tip_count"]
+
+    def empty(self) -> None:
+        """清空废枪头盒"""
+        self._unilabos_state["tip_count"] = 0
+
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+
+class CoincellDeck(Deck):
+    """纽扣电池组装工作站台面类"""
+
+    def __init__(
+        self,
+        name: str = "coin_cell_deck",
+        size_x: float = 1450.0,  # 1m
+        size_y: float = 1450.0,  # 1m
+        size_z: float = 100.0,   # 0.9m
+        origin: Coordinate = Coordinate(-2200, 0, 0),
+        category: str = "coin_cell_deck",
+        setup: bool = False,  # 是否自动执行 setup
+    ):
+        """初始化纽扣电池组装工作站台面
+
+        Args:
+            name: 台面名称
+            size_x: 长度 (mm) - 1m
+            size_y: 宽度 (mm) - 1m
+            size_z: 高度 (mm) - 0.9m
+            origin: 原点坐标
+            category: 类别
+            setup: 是否自动执行 setup 配置标准布局
+        """
+        super().__init__(
+            name=name,
+            size_x=1450.0,
+            size_y=1450.0,
+            size_z=100.0,
+            origin=origin,
+        )
+        if setup:
+            self.setup()
+
+    def setup(self) -> None:
+        """设置工作站的标准布局 - 包含子弹夹、料盘、瓶架等完整配置"""
+        # ====================================== 子弹夹 ============================================
+        
+        # 正极片（4个洞位，2x2布局）
+        zhengji_zip = MagazineHolder_4_Cathode("正极&铝箔弹夹")
+        self.assign_child_resource(zhengji_zip, Coordinate(x=402.0, y=830.0, z=0))
+        
+        # 正极壳、平垫片（6个洞位，2x2+2布局）
+        zhengjike_zip = MagazineHolder_6_Cathode("正极壳&平垫片弹夹")
+        self.assign_child_resource(zhengjike_zip, Coordinate(x=566.0, y=272.0, z=0))
+        
+        # 负极壳、弹垫片（6个洞位，2x2+2布局）
+        fujike_zip = MagazineHolder_6_Anode("负极壳&弹垫片弹夹")
+        self.assign_child_resource(fujike_zip, Coordinate(x=474.0, y=276.0, z=0))
+        
+        # 成品弹夹（6个洞位，3x2布局）
+        chengpindanjia_zip = MagazineHolder_6_Battery("成品弹夹")
+        self.assign_child_resource(chengpindanjia_zip, Coordinate(x=260.0, y=156.0, z=0))
+        
+        # ====================================== 物料板 ============================================
+        # 创建物料板（料盘carrier）- 4x4布局
+        # 负极料盘
+        fujiliaopan = MaterialPlate(name="负极料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
+        self.assign_child_resource(fujiliaopan, Coordinate(x=708.0, y=794.0, z=0))
+        # for i in range(16):
+        #     fujipian = ElectrodeSheet(name=f"{fujiliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
+        #     fujiliaopan.children[i].assign_child_resource(fujipian, location=None)
+
+        # 隔膜料盘
+        gemoliaopan = MaterialPlate(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
+        self.assign_child_resource(gemoliaopan, Coordinate(x=718.0, y=918.0, z=0))
+        # for i in range(16):
+        #     gemopian = ElectrodeSheet(name=f"{gemoliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
+        #     gemoliaopan.children[i].assign_child_resource(gemopian, location=None)
+
+        # ====================================== 瓶架、移液枪 ============================================
+        # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒
+        # 奔耀上料5ml分液瓶小板 - 由奔曜跨站转运而来，不单独写，但是这里应该有一个堆栈用于摆放分液瓶小板
+        
+        # bottle_rack_3x4 = BottleRack(
+        #     name="bottle_rack_3x4",
+        #     size_x=210.0,
+        #     size_y=140.0,
+        #     size_z=100.0,
+        #     num_items_x=2,
+        #     num_items_y=4,
+        #     position_spacing=35.0,
+        #     orientation="vertical",
+        # )
+        # self.assign_child_resource(bottle_rack_3x4, Coordinate(x=1542.0, y=717.0, z=0))
+        
+        # 电解液缓存位 - 6x2布局
+        bottle_rack_6x2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2")
+        self.assign_child_resource(bottle_rack_6x2, Coordinate(x=1050.0, y=358.0, z=0))
+        # 电解液回收位6x2
+        bottle_rack_6x2_2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2_2")
+        self.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=914.0, y=358.0, z=0))
+
+        tip_box = TipBox64(name="tip_box_64")
+        self.assign_child_resource(tip_box, Coordinate(x=782.0, y=514.0, z=0))
+
+        waste_tip_box = WasteTipBox(name="waste_tip_box")
+        self.assign_child_resource(waste_tip_box, Coordinate(x=778.0, y=622.0, z=0))
+
+
+if __name__ == "__main__":
+    deck = create_coin_cell_deck()
+    print(deck)

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py

@@ -1,44 +1,134 @@
+      
 import csv
+import inspect
 import json
 import os
 import threading
 import time
+import types
 from datetime import datetime
 from typing import Any, Dict, Optional
-from pylabrobot.resources import Resource as PLRResource
+from functools import wraps
+from pylabrobot.resources import Deck, Resource as PLRResource
 from unilabos_msgs.msg import Resource
 from unilabos.device_comms.modbus_plc.client import ModbusTcpClient
-from unilabos.devices.workstation.coin_cell_assembly.button_battery_station import MaterialHole, MaterialPlate
 from unilabos.devices.workstation.workstation_base import WorkstationBase
 from unilabos.device_comms.modbus_plc.client import TCPClient, ModbusNode, PLCWorkflow, ModbusWorkflow, WorkflowAction, BaseClient
 from unilabos.device_comms.modbus_plc.modbus import DeviceType, Base as ModbusNodeBase, DataType, WorderOrder
-from unilabos.devices.workstation.coin_cell_assembly.button_battery_station import *
+from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import *
 from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode
 from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
+from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import CoincellDeck
+from unilabos.resources.graphio import convert_resources_to_type
+from unilabos.utils.log import logger
+
+
+def _ensure_modbus_slave_kw_alias(modbus_client):
+    if modbus_client is None:
+        return
+
+    method_names = [
+        "read_coils",
+        "write_coils",
+        "write_coil",
+        "read_discrete_inputs",
+        "read_holding_registers",
+        "write_register",
+        "write_registers",
+    ]
+
+    def _wrap(func):
+        signature = inspect.signature(func)
+        has_var_kwargs = any(param.kind == param.VAR_KEYWORD for param in signature.parameters.values())
+        accepts_unit = has_var_kwargs or "unit" in signature.parameters
+        accepts_slave = has_var_kwargs or "slave" in signature.parameters
+
+        @wraps(func)
+        def _wrapped(self, *args, **kwargs):
+            if "slave" in kwargs and not accepts_slave:
+                slave_value = kwargs.pop("slave")
+                if accepts_unit and "unit" not in kwargs:
+                    kwargs["unit"] = slave_value
+            if "unit" in kwargs and not accepts_unit:
+                unit_value = kwargs.pop("unit")
+                if accepts_slave and "slave" not in kwargs:
+                    kwargs["slave"] = unit_value
+            return func(self, *args, **kwargs)
+
+        _wrapped._has_slave_alias = True
+        return _wrapped
+
+    for name in method_names:
+        if not hasattr(modbus_client, name):
+            continue
+        bound_method = getattr(modbus_client, name)
+        func = getattr(bound_method, "__func__", None)
+        if func is None:
+            continue
+        if getattr(func, "_has_slave_alias", False):
+            continue
+        wrapped = _wrap(func)
+        setattr(modbus_client, name, types.MethodType(wrapped, modbus_client))
+
+
+def _coerce_deck_input(deck: Any) -> Optional[Deck]:
+    if deck is None:
+        return None
+
+    if isinstance(deck, Deck):
+        return deck
+
+    if isinstance(deck, PLRResource):
+        return deck if isinstance(deck, Deck) else None
+
+    candidates = None
+    if isinstance(deck, dict):
+        if "nodes" in deck and isinstance(deck["nodes"], list):
+            candidates = deck["nodes"]
+        else:
+            candidates = [deck]
+    elif isinstance(deck, list):
+        candidates = deck
+
+    if candidates is None:
+        return None
+
+    try:
+        converted = convert_resources_to_type(resources_list=candidates, resource_type=Deck)
+        if isinstance(converted, Deck):
+            return converted
+        if isinstance(converted, list):
+            for item in converted:
+                if isinstance(item, Deck):
+                    return item
+    except Exception as exc:
+        logger.warning(f"deck 转换 Deck 失败: {exc}")
+    return None
+
 
 #构建物料系统
 
 class CoinCellAssemblyWorkstation(WorkstationBase):
-    def __init__(
-        self,
-        deck: CoincellDeck,
-        address: str = "192.168.1.20",
+    def __init__(self, 
+        config: dict = None, 
+        deck=None, 
+        address: str = "172.16.28.102",
         port: str = "502",
-        debug_mode: bool = True,
+        debug_mode: bool = False,
         *args,
-        **kwargs,
-    ):
-        super().__init__(
-            #桌子
-            deck=deck,
-            *args,
-            **kwargs,
-        )
+        **kwargs):
+
+        if deck is None and config:
+            deck = config.get('deck')
+        if deck is None:
+            logger.info("没有传入依华deck，检查启动json文件")
+        super().__init__(deck=deck, *args, **kwargs,)
         self.debug_mode = debug_mode
-        self.deck = deck
+ 
         """ 连接初始化 """
         modbus_client = TCPClient(addr=address, port=port)
-        print("modbus_client", modbus_client)
+        logger.debug(f"创建 Modbus 客户端: {modbus_client}")
+        _ensure_modbus_slave_kw_alias(modbus_client.client)
         if not debug_mode:
             modbus_client.client.connect()
             count = 100
@@ -49,27 +139,21 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                 time.sleep(2)
             if not modbus_client.client.is_socket_open():
                 raise ValueError('modbus tcp connection failed')
+            self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_1105.csv'))
+            self.client = modbus_client.register_node_list(self.nodes)
         else:
             print("测试模式，跳过连接")
+            self.nodes, self.client = None, None
 
         """ 工站的配置 """
-        self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_a.csv'))
-        self.client  = modbus_client.register_node_list(self.nodes)
+
         self.success = False
         self.allow_data_read = False  #允许读取函数运行标志位
         self.csv_export_thread = None
         self.csv_export_running = False
         self.csv_export_file = None
-        #创建一个物料台面，包含两个极片板
-        #self.deck = create_a_coin_cell_deck()
-        
-        #self._ros_node.update_resource(self.deck)
-        
-        #ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
-        #    "resources": [self.deck]
-        #})
+        self.coin_num_N = 0  #已组装电池数量
 
-    
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
         #self.deck = create_a_coin_cell_deck()
@@ -491,11 +575,11 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         try:
             # 尝试不同的字节序读取
             code_little, read_err = self.client.use_node('REG_DATA_COIN_CELL_CODE').read(10, word_order=WorderOrder.LITTLE)
-            print(code_little)
+            # logger.debug(f"读取电池二维码原始数据: {code_little}")
             clean_code = code_little[-8:][::-1]
             return clean_code
         except Exception as e:
-            print(f"读取电池二维码失败: {e}")
+            logger.error(f"读取电池二维码失败: {e}")
             return "N/A"
 
 
@@ -504,11 +588,11 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         try:
             # 尝试不同的字节序读取
             code_little, read_err = self.client.use_node('REG_DATA_ELECTROLYTE_CODE').read(10, word_order=WorderOrder.LITTLE)
-            print(code_little)
+            # logger.debug(f"读取电解液二维码原始数据: {code_little}")
             clean_code = code_little[-8:][::-1]
             return clean_code
         except Exception as e:
-            print(f"读取电解液二维码失败: {e}")
+            logger.error(f"读取电解液二维码失败: {e}")
             return "N/A"
 
     # ===================== 环境监控区 ======================
@@ -606,7 +690,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 +739,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: 
@@ -688,15 +782,32 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         data_coin_num = self.data_coin_num
         data_electrolyte_code = self.data_electrolyte_code
         data_coin_cell_code = self.data_coin_cell_code
-        print("data_open_circuit_voltage", data_open_circuit_voltage)
-        print("data_pole_weight", data_pole_weight)
-        print("data_assembly_time", data_assembly_time)
-        print("data_assembly_pressure", data_assembly_pressure)
-        print("data_electrolyte_volume", data_electrolyte_volume)
-        print("data_coin_num", data_coin_num)
-        print("data_electrolyte_code", data_electrolyte_code)
-        print("data_coin_cell_code", data_coin_cell_code)
+        logger.debug(f"data_open_circuit_voltage: {data_open_circuit_voltage}")
+        logger.debug(f"data_pole_weight: {data_pole_weight}")
+        logger.debug(f"data_assembly_time: {data_assembly_time}")
+        logger.debug(f"data_assembly_pressure: {data_assembly_pressure}")
+        logger.debug(f"data_electrolyte_volume: {data_electrolyte_volume}")
+        logger.debug(f"data_coin_num: {data_coin_num}")
+        logger.debug(f"data_electrolyte_code: {data_electrolyte_code}")
+        logger.debug(f"data_coin_cell_code: {data_coin_cell_code}")
         #接收完信息后，读取完毕标志位置True
+        liaopan3 = self.deck.get_resource("成品弹夹")        
+        #把物料解绑后放到另一盘上
+        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.deck]
+        })
+
+
         self._unilab_rec_msg_succ_cmd(True)
         time.sleep(1)
         #等待允许读取标志位置False
@@ -754,11 +865,25 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         self.success = True
         return self.success
 
+    def qiming_coin_cell_code(self, fujipian_panshu:int, fujipian_juzhendianwei:int=0, gemopanshu:int=0, gemo_juzhendianwei:int=0, lvbodian:bool=True, battery_pressure_mode:bool=True, battery_pressure:int=4000, battery_clean_ignore:bool=False) -> bool:
+        self.success = False
+        self.client.use_node('REG_MSG_NE_PLATE_NUM').write(fujipian_panshu)
+        self.client.use_node('REG_MSG_NE_PLATE_MATRIX').write(fujipian_juzhendianwei)
+        self.client.use_node('REG_MSG_SEPARATOR_PLATE_NUM').write(gemopanshu)
+        self.client.use_node('REG_MSG_SEPARATOR_PLATE_MATRIX').write(gemo_juzhendianwei)
+        self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian)
+        self.client.use_node('REG_MSG_PRESS_MODE').write(not battery_pressure_mode)
+        # self.client.use_node('REG_MSG_ASSEMBLY_PRESSURE').write(battery_pressure)
+        self.client.use_node('REG_MSG_BATTERY_CLEAN_IGNORE').write(battery_clean_ignore)
+        self.success = True
+        
+        return self.success
 
-
-    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="/Users/sml/work") -> 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):
             read_status_flag = True
             with open(summary_csv_file, 'r', newline='', encoding='utf-8') as csvfile:
@@ -784,54 +909,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 +951,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,36 +988,27 @@ 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.deck.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.deck]
+            })
+            # for i in range(40):
+            #     print(f"fun_wuliao_test 运行结束{i}")
+            #     time.sleep(1)
+            # time.sleep(40)
     # 数据读取与输出
-    def func_read_data_and_output(self, file_path: str="D:\\coin_cell_data"):
+    def func_read_data_and_output(self, file_path: str="/Users/sml/work"):
         # 检查CSV导出是否正在运行，已运行则跳出，防止同时启动两个while循环
         if self.csv_export_running:
             return False, "读取已在运行中"
@@ -1012,7 +1113,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():
@@ -1102,41 +1203,16 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
     '''
 
 
+
 if __name__ == "__main__":
-    from pylabrobot.resources import Resource
-    Coin_Cell = CoinCellAssemblyWorkstation(Resource("1", 1, 1, 1), debug_mode=True)
-    #Coin_Cell.func_pack_device_init()  
-    #Coin_Cell.func_pack_device_auto()
-    #Coin_Cell.func_pack_device_start()
-    #Coin_Cell.func_pack_send_bottle_num(2)
-    #Coin_Cell.func_pack_send_msg_cmd(2)
-    #Coin_Cell.func_pack_get_msg_cmd()
-    #Coin_Cell.func_pack_get_msg_cmd()
-    #Coin_Cell.func_pack_send_finished_cmd()
-#
-    #Coin_Cell.func_allpack_cmd(3, 2)
-    #print(Coin_Cell.data_stack_vision_code)
-    #print("success")
-    #创建一个物料台面
-
-    #deck = create_a_coin_cell_deck()
-
-    ##在台面上找到料盘和极片
-    #liaopan1 = deck.get_resource("liaopan1")
-    #liaopan2 = deck.get_resource("liaopan2")
-    #jipian1 = liaopan1.children[1].children[0]
-#
-    ##print(jipian1)
-    ##把物料解绑后放到另一盘上
-    #jipian1.parent.unassign_child_resource(jipian1)
-    #liaopan2.children[1].assign_child_resource(jipian1, location=None)
-    ##print(jipian2.parent)
-    from unilabos.resources.graphio import resource_ulab_to_plr, convert_resources_to_type
-
-    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)
-
+    # 简单测试
+    workstation = CoinCellAssemblyWorkstation(deck=CoincellDeck(setup=True, name="coin_cell_deck"))
+    # workstation.qiming_coin_cell_code(fujipian_panshu=1, fujipian_juzhendianwei=2, gemopanshu=3, gemo_juzhendianwei=4, lvbodian=False, battery_pressure_mode=False, battery_pressure=4200, battery_clean_ignore=False)
+    # print(f"工作站创建成功: {workstation.deck.name}")
+    # print(f"料盘数量: {len(workstation.deck.children)}")
+    workstation.func_pack_device_init()
+    workstation.func_pack_device_auto()
+    workstation.func_pack_device_start()
+    workstation.func_pack_send_bottle_num(16)
+    workstation.func_allpack_cmd(elec_num=16, elec_use_num=16, elec_vol=50, assembly_type=7, assembly_pressure=4200, file_path="/Users/calvincao/Desktop/work/Uni-Lab-OS-hhm")
+    

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_1105.csv

@@ -0,0 +1,64 @@
+Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
+COIL_SYS_START_CMD,BOOL,,,,coil,9010,
+COIL_SYS_STOP_CMD,BOOL,,,,coil,9020,
+COIL_SYS_RESET_CMD,BOOL,,,,coil,9030,
+COIL_SYS_HAND_CMD,BOOL,,,,coil,9040,
+COIL_SYS_AUTO_CMD,BOOL,,,,coil,9050,
+COIL_SYS_INIT_CMD,BOOL,,,,coil,9060,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,9700,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,9710,unilab_rec_msg_succ_cmd
+COIL_SYS_START_STATUS,BOOL,,,,coil,9210,
+COIL_SYS_STOP_STATUS,BOOL,,,,coil,9220,
+COIL_SYS_RESET_STATUS,BOOL,,,,coil,9230,
+COIL_SYS_HAND_STATUS,BOOL,,,,coil,9240,
+COIL_SYS_AUTO_STATUS,BOOL,,,,coil,9250,
+COIL_SYS_INIT_STATUS,BOOL,,,,coil,9260,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,9500,
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,9510,request_send_msg_status
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,17000,
+REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,17002,unilab_send_msg_electrolyte_num
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,17004,unilab_send_msg_electrolyte_vol
+REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,17006,unilab_send_msg_assembly_type
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,17008,unilab_send_msg_assembly_pressure
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,16000,data_assembly_coin_cell_num
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,16002,data_open_circuit_voltage
+REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,16004,
+REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,16006,
+REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,16008,
+REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,16010,data_pole_weight
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,16012,data_assembly_time
+REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,16014,data_assembly_pressure
+REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,16016,data_electrolyte_volume
+REG_DATA_COIN_NUM,INT16,,,,hold_register,16018,data_coin_num
+REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,16020,data_electrolyte_code()
+REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,16030,data_coin_cell_code()
+REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,18004,data_stack_vision_code()
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,16050,data_glove_box_pressure
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,16052,data_glove_box_water_content
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,16054,data_glove_box_o2_content
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,9720,
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,9520,
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,17496,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,16000,
+UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,9730,
+UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,9530,
+REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,16018,ASSEMBLY_TYPE7or8
+COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,9340,
+REG_MSG_NE_PLATE_MATRIX,INT16,,负极片矩阵点位,,hold_register,17440,
+REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,隔膜矩阵点位,,hold_register,17450,
+REG_MSG_TIP_BOX_MATRIX,INT16,,移液枪头矩阵点位,,hold_register,17480,
+REG_MSG_NE_PLATE_NUM,INT16,,负极片盘数,,hold_register,17443,
+REG_MSG_SEPARATOR_PLATE_NUM,INT16,,隔膜盘数,,hold_register,17453,
+REG_MSG_PRESS_MODE,BOOL,,压制模式（false:压力检测模式，True:距离模式）,,coil,9360,电池压制模式
+,,,,,,,
+,BOOL,,视觉对位（false:使用，true:忽略）,,coil,9300,视觉对位
+,BOOL,,复检（false:使用，true:忽略）,,coil,9310,视觉复检
+,BOOL,,手套箱_左仓（false:使用，true:忽略）,,coil,9320,手套箱左仓
+,BOOL,,手套箱_右仓（false:使用，true:忽略）,,coil,9420,手套箱右仓
+,BOOL,,真空检知（false:使用，true:忽略）,,coil,9350,真空检知
+,BOOL,,电解液添加模式（false:单次滴液，true:二次滴液）,,coil,9370,滴液模式
+,BOOL,,正极片称重（false:使用，true:忽略）,,coil,9380,正极片称重
+,BOOL,,正负极片组装方式（false:正装，true:倒装）,,coil,9390,正负极反装
+,BOOL,,压制清洁（false:使用，true:忽略）,,coil,9400,压制清洁
+,BOOL,,物料盘摆盘方式（false:水平摆盘，true:堆叠摆盘）,,coil,9410,负极片摆盘方式
+REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,忽略电池清洁（false:使用，true:忽略）,,coil,9460,

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_a.csv

@@ -0,0 +1,64 @@
+Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
+COIL_SYS_START_CMD,BOOL,,,,coil,8010,
+COIL_SYS_STOP_CMD,BOOL,,,,coil,8020,
+COIL_SYS_RESET_CMD,BOOL,,,,coil,8030,
+COIL_SYS_HAND_CMD,BOOL,,,,coil,8040,
+COIL_SYS_AUTO_CMD,BOOL,,,,coil,8050,
+COIL_SYS_INIT_CMD,BOOL,,,,coil,8060,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,8700,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,8710,unilab_rec_msg_succ_cmd
+COIL_SYS_START_STATUS,BOOL,,,,coil,8210,
+COIL_SYS_STOP_STATUS,BOOL,,,,coil,8220,
+COIL_SYS_RESET_STATUS,BOOL,,,,coil,8230,
+COIL_SYS_HAND_STATUS,BOOL,,,,coil,8240,
+COIL_SYS_AUTO_STATUS,BOOL,,,,coil,8250,
+COIL_SYS_INIT_STATUS,BOOL,,,,coil,8260,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,8500,
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,8510,request_send_msg_status
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,11000,
+REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,11002,unilab_send_msg_electrolyte_num
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,11004,unilab_send_msg_electrolyte_vol
+REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,11006,unilab_send_msg_assembly_type
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,11008,unilab_send_msg_assembly_pressure
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,10000,data_assembly_coin_cell_num
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,10002,data_open_circuit_voltage
+REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,10004,
+REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,10006,
+REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,10008,
+REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,10010,data_pole_weight
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,10012,data_assembly_time
+REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,10014,data_assembly_pressure
+REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,10016,data_electrolyte_volume
+REG_DATA_COIN_NUM,INT16,,,,hold_register,10018,data_coin_num
+REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,10020,data_electrolyte_code()
+REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,10030,data_coin_cell_code()
+REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,12004,data_stack_vision_code()
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,10050,data_glove_box_pressure
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,10052,data_glove_box_water_content
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,10054,data_glove_box_o2_content
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8720,
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8520,
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,496,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,10000,
+UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,8730,
+UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,8530,
+REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,10018,ASSEMBLY_TYPE7or8
+COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,8340,
+REG_MSG_NE_PLATE_MATRIX,INT16,,负极片矩阵点位,,hold_register,440,
+REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,隔膜矩阵点位,,hold_register,450,
+REG_MSG_TIP_BOX_MATRIX,INT16,,移液枪头矩阵点位,,hold_register,480,
+REG_MSG_NE_PLATE_NUM,INT16,,负极片盘数,,hold_register,443,
+REG_MSG_SEPARATOR_PLATE_NUM,INT16,,隔膜盘数,,hold_register,453,
+REG_MSG_PRESS_MODE,BOOL,,压制模式（false:压力检测模式，True:距离模式）,,coil,8360,电池压制模式
+,,,,,,,
+,BOOL,,视觉对位（false:使用，true:忽略）,,coil,8300,视觉对位
+,BOOL,,复检（false:使用，true:忽略）,,coil,8310,视觉复检
+,BOOL,,手套箱_左仓（false:使用，true:忽略）,,coil,8320,手套箱左仓
+,BOOL,,手套箱_右仓（false:使用，true:忽略）,,coil,8420,手套箱右仓
+,BOOL,,真空检知（false:使用，true:忽略）,,coil,8350,真空检知
+,BOOL,,电解液添加模式（false:单次滴液，true:二次滴液）,,coil,8370,滴液模式
+,BOOL,,正极片称重（false:使用，true:忽略）,,coil,8380,正极片称重
+,BOOL,,正负极片组装方式（false:正装，true:倒装）,,coil,8390,正负极反装
+,BOOL,,压制清洁（false:使用，true:忽略）,,coil,8400,压制清洁
+,BOOL,,物料盘摆盘方式（false:水平摆盘，true:堆叠摆盘）,,coil,8410,负极片摆盘方式
+REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,忽略电池清洁（false:使用，true:忽略）,,coil,8460,

unilabos/devices/workstation/coin_cell_assembly/new_cellconfig3c.json

@@ -0,0 +1,39 @@
+{
+  "nodes": [
+    {
+      "id": "bioyond_cell_workstation",
+      "name": "配液分液工站",
+      "children": [
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "bioyond_cell",
+      "config": {
+          "protocol_type": [],
+          "station_resource": {}
+      },
+      "data": {}
+  },
+
+  {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "children": [
+          "coin_cell_deck"
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "coincellassemblyworkstation_device",
+      "position": {
+          "x": -600,
+          "y": -400,
+          "z": 0
+      },
+      "config": {
+          "debug_mode": false,
+          "protocol_type": []
+      }
+    }
+  ],
+  "links": []
+}

unilabos/devices/workstation/workstation_base.py

@@ -171,7 +171,6 @@ class WorkstationBase(ABC):
     def post_init(self, ros_node: ROS2WorkstationNode) -> None:
         # 初始化物料系统
         self._ros_node = ros_node
-        self._ros_node.update_resource([self.deck])
 
     def _build_resource_mappings(self, deck: Deck):
         """递归构建资源映射"""

unilabos/devices/workstation/workstation_material_management.py

@@ -1,583 +0,0 @@
-"""
-工作站物料管理基类
-Workstation Material Management Base Class
-
-基于PyLabRobot的物料管理系统
-"""
-from typing import Dict, Any, List, Optional, Union, Type
-from abc import ABC, abstractmethod
-import json
-
-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
-
-
-class MaterialManagementBase(ABC):
-    """物料管理基类
-    
-    定义工作站物料管理的标准接口：
-    1. 物料初始化 - 根据配置创建物料资源
-    2. 物料追踪 - 实时跟踪物料位置和状态
-    3. 物料查找 - 按类型、位置、状态查找物料
-    4. 物料转换 - PyLabRobot与UniLab资源格式转换
-    """
-
-    def __init__(
-        self,
-        device_id: str,
-        deck_config: Dict[str, Any],
-        resource_tracker: DeviceNodeResourceTracker,
-        children_config: Dict[str, Dict[str, Any]] = None
-    ):
-        self.device_id = device_id
-        self.deck_config = deck_config
-        self.resource_tracker = resource_tracker
-        self.children_config = children_config or {}
-        
-        # 创建主台面
-        self.plr_deck = self._create_deck()
-        
-        # 扩展ResourceTracker
-        self._extend_resource_tracker()
-        
-        # 注册deck到resource tracker
-        self.resource_tracker.add_resource(self.plr_deck)
-        
-        # 初始化子资源
-        self.plr_resources = {}
-        self._initialize_materials()
-
-    def _create_deck(self) -> Deck:
-        """创建主台面"""
-        return Deck(
-            name=f"{self.device_id}_deck",
-            size_x=self.deck_config.get("size_x", 1000.0),
-            size_y=self.deck_config.get("size_y", 1000.0),
-            size_z=self.deck_config.get("size_z", 500.0),
-            origin=PLRCoordinate(0, 0, 0)
-        )
-
-    def _extend_resource_tracker(self):
-        """扩展ResourceTracker以支持PyLabRobot特定功能"""
-        
-        def find_by_type(resource_type):
-            """按类型查找资源"""
-            return self._find_resources_by_type_recursive(self.plr_deck, resource_type)
-        
-        def find_by_category(category: str):
-            """按类别查找资源"""
-            found = []
-            for resource in self._get_all_resources():
-                if hasattr(resource, 'category') and resource.category == category:
-                    found.append(resource)
-            return found
-        
-        def find_by_name_pattern(pattern: str):
-            """按名称模式查找资源"""
-            import re
-            found = []
-            for resource in self._get_all_resources():
-                if re.search(pattern, resource.name):
-                    found.append(resource)
-            return found
-        
-        # 动态添加方法到resource_tracker
-        self.resource_tracker.find_by_type = find_by_type
-        self.resource_tracker.find_by_category = find_by_category
-        self.resource_tracker.find_by_name_pattern = find_by_name_pattern
-
-    def _find_resources_by_type_recursive(self, resource, target_type):
-        """递归查找指定类型的资源"""
-        found = []
-        if isinstance(resource, target_type):
-            found.append(resource)
-        
-        # 递归查找子资源
-        children = getattr(resource, "children", [])
-        for child in children:
-            found.extend(self._find_resources_by_type_recursive(child, target_type))
-        
-        return found
-
-    def _get_all_resources(self) -> List[PLRResource]:
-        """获取所有资源"""
-        all_resources = []
-        
-        def collect_resources(resource):
-            all_resources.append(resource)
-            children = getattr(resource, "children", [])
-            for child in children:
-                collect_resources(child)
-        
-        collect_resources(self.plr_deck)
-        return all_resources
-
-    def _initialize_materials(self):
-        """初始化物料"""
-        try:
-            # 确定创建顺序，确保父资源先于子资源创建
-            creation_order = self._determine_creation_order()
-            
-            # 按顺序创建资源
-            for resource_id in creation_order:
-                config = self.children_config[resource_id]
-                self._create_plr_resource(resource_id, config)
-            
-            logger.info(f"物料管理系统初始化完成，共创建 {len(self.plr_resources)} 个资源")
-            
-        except Exception as e:
-            logger.error(f"物料初始化失败: {e}")
-
-    def _determine_creation_order(self) -> List[str]:
-        """确定资源创建顺序"""
-        order = []
-        visited = set()
-        
-        def visit(resource_id: str):
-            if resource_id in visited:
-                return
-            visited.add(resource_id)
-            
-            config = self.children_config.get(resource_id, {})
-            parent_id = config.get("parent")
-            
-            # 如果有父资源，先访问父资源
-            if parent_id and parent_id in self.children_config:
-                visit(parent_id)
-            
-            order.append(resource_id)
-        
-        for resource_id in self.children_config:
-            visit(resource_id)
-        
-        return order
-
-    def _create_plr_resource(self, resource_id: str, config: Dict[str, Any]):
-        """创建PyLabRobot资源"""
-        try:
-            resource_type = config.get("type", "unknown")
-            data = config.get("data", {})
-            location_config = config.get("location", {})
-            
-            # 创建位置坐标
-            location = PLRCoordinate(
-                x=location_config.get("x", 0.0),
-                y=location_config.get("y", 0.0),
-                z=location_config.get("z", 0.0)
-            )
-            
-            # 根据类型创建资源
-            resource = self._create_resource_by_type(resource_id, resource_type, config, data, location)
-            
-            if resource:
-                # 设置父子关系
-                parent_id = config.get("parent")
-                if parent_id and parent_id in self.plr_resources:
-                    parent_resource = self.plr_resources[parent_id]
-                    parent_resource.assign_child_resource(resource, location)
-                else:
-                    # 直接放在deck上
-                    self.plr_deck.assign_child_resource(resource, location)
-                
-                # 保存资源引用
-                self.plr_resources[resource_id] = resource
-                
-                # 注册到resource tracker
-                self.resource_tracker.add_resource(resource)
-                
-                logger.debug(f"创建资源成功: {resource_id} ({resource_type})")
-            
-        except Exception as e:
-            logger.error(f"创建资源失败 {resource_id}: {e}")
-
-    @abstractmethod
-    def _create_resource_by_type(
-        self, 
-        resource_id: str, 
-        resource_type: str, 
-        config: Dict[str, Any], 
-        data: Dict[str, Any], 
-        location: PLRCoordinate
-    ) -> Optional[PLRResource]:
-        """根据类型创建资源 - 子类必须实现"""
-        pass
-
-    # ============ 物料查找接口 ============
-    
-    def find_materials_by_type(self, material_type: str) -> List[PLRResource]:
-        """按材料类型查找物料"""
-        return self.resource_tracker.find_by_category(material_type)
-
-    def find_material_by_id(self, resource_id: str) -> Optional[PLRResource]:
-        """按ID查找物料"""
-        return self.plr_resources.get(resource_id)
-
-    def find_available_positions(self, position_type: str) -> List[PLRResource]:
-        """查找可用位置"""
-        positions = self.resource_tracker.find_by_category(position_type)
-        available = []
-        
-        for pos in positions:
-            if hasattr(pos, 'is_available') and pos.is_available():
-                available.append(pos)
-            elif hasattr(pos, 'children') and len(pos.children) == 0:
-                available.append(pos)
-        
-        return available
-
-    def get_material_inventory(self) -> Dict[str, int]:
-        """获取物料库存统计"""
-        inventory = {}
-        
-        for resource in self._get_all_resources():
-            if hasattr(resource, 'category'):
-                category = resource.category
-                inventory[category] = inventory.get(category, 0) + 1
-        
-        return inventory
-
-    # ============ 物料状态更新接口 ============
-    
-    def update_material_location(self, material_id: str, new_location: PLRCoordinate) -> bool:
-        """更新物料位置"""
-        try:
-            material = self.find_material_by_id(material_id)
-            if material:
-                material.location = new_location
-                return True
-            return False
-        except Exception as e:
-            logger.error(f"更新物料位置失败: {e}")
-            return False
-
-    def move_material(self, material_id: str, target_container_id: str) -> bool:
-        """移动物料到目标容器"""
-        try:
-            material = self.find_material_by_id(material_id)
-            target = self.find_material_by_id(target_container_id)
-            
-            if material and target:
-                # 从原位置移除
-                if material.parent:
-                    material.parent.unassign_child_resource(material)
-                
-                # 添加到新位置
-                target.assign_child_resource(material)
-                return True
-            
-            return False
-            
-        except Exception as e:
-            logger.error(f"移动物料失败: {e}")
-            return False
-
-    # ============ 资源转换接口 ============
-    
-    def convert_to_unilab_format(self, plr_resource: PLRResource) -> Dict[str, Any]:
-        """将PyLabRobot资源转换为UniLab格式"""
-        return resource_plr_to_ulab(plr_resource)
-
-    def convert_from_unilab_format(self, unilab_resource: Dict[str, Any]) -> PLRResource:
-        """将UniLab格式转换为PyLabRobot资源"""
-        return resource_ulab_to_plr(unilab_resource)
-
-    def get_deck_state(self) -> Dict[str, Any]:
-        """获取Deck状态"""
-        try:
-            return {
-                "deck_info": {
-                    "name": self.plr_deck.name,
-                    "size": {
-                        "x": self.plr_deck.size_x,
-                        "y": self.plr_deck.size_y,
-                        "z": self.plr_deck.size_z
-                    },
-                    "children_count": len(self.plr_deck.children)
-                },
-                "resources": {
-                    resource_id: self.convert_to_unilab_format(resource)
-                    for resource_id, resource in self.plr_resources.items()
-                },
-                "inventory": self.get_material_inventory()
-            }
-        except Exception as e:
-            logger.error(f"获取Deck状态失败: {e}")
-            return {"error": str(e)}
-
-    # ============ 数据持久化接口 ============
-    
-    def save_state_to_file(self, file_path: str) -> bool:
-        """保存状态到文件"""
-        try:
-            state = self.get_deck_state()
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(state, f, indent=2, ensure_ascii=False)
-            logger.info(f"状态已保存到: {file_path}")
-            return True
-        except Exception as e:
-            logger.error(f"保存状态失败: {e}")
-            return False
-
-    def load_state_from_file(self, file_path: str) -> bool:
-        """从文件加载状态"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                state = json.load(f)
-            
-            # 重新创建资源
-            self._recreate_resources_from_state(state)
-            logger.info(f"状态已从文件加载: {file_path}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"加载状态失败: {e}")
-            return False
-
-    def _recreate_resources_from_state(self, state: Dict[str, Any]):
-        """从状态重新创建资源"""
-        # 清除现有资源
-        self.plr_resources.clear()
-        self.plr_deck.children.clear()
-        
-        # 从状态重新创建
-        resources_data = state.get("resources", {})
-        for resource_id, resource_data in resources_data.items():
-            try:
-                plr_resource = self.convert_from_unilab_format(resource_data)
-                self.plr_resources[resource_id] = plr_resource
-                self.plr_deck.assign_child_resource(plr_resource)
-            except Exception as e:
-                logger.error(f"重新创建资源失败 {resource_id}: {e}")
-
-
-class CoinCellMaterialManagement(MaterialManagementBase):
-    """纽扣电池物料管理类
-    
-    从 button_battery_station 抽取的物料管理功能
-    """
-
-    def _create_resource_by_type(
-        self, 
-        resource_id: str, 
-        resource_type: str, 
-        config: Dict[str, Any], 
-        data: Dict[str, Any], 
-        location: PLRCoordinate
-    ) -> Optional[PLRResource]:
-        """根据类型创建纽扣电池相关资源"""
-        
-        # 导入纽扣电池资源类
-        from unilabos.device_comms.button_battery_station import (
-            MaterialPlate, PlateSlot, ClipMagazine, BatteryPressSlot,
-            TipBox64, WasteTipBox, BottleRack, Battery, ElectrodeSheet
-        )
-        
-        try:
-            if resource_type == "material_plate":
-                return self._create_material_plate(resource_id, config, data, location)
-            
-            elif resource_type == "plate_slot":
-                return self._create_plate_slot(resource_id, config, data, location)
-            
-            elif resource_type == "clip_magazine":
-                return self._create_clip_magazine(resource_id, config, data, location)
-            
-            elif resource_type == "battery_press_slot":
-                return self._create_battery_press_slot(resource_id, config, data, location)
-            
-            elif resource_type == "tip_box":
-                return self._create_tip_box(resource_id, config, data, location)
-            
-            elif resource_type == "waste_tip_box":
-                return self._create_waste_tip_box(resource_id, config, data, location)
-            
-            elif resource_type == "bottle_rack":
-                return self._create_bottle_rack(resource_id, config, data, location)
-            
-            elif resource_type == "battery":
-                return self._create_battery(resource_id, config, data, location)
-            
-            else:
-                logger.warning(f"未知的资源类型: {resource_type}")
-                return None
-                
-        except Exception as e:
-            logger.error(f"创建资源失败 {resource_id} ({resource_type}): {e}")
-            return None
-
-    def _create_material_plate(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建料板"""
-        from unilabos.device_comms.button_battery_station import MaterialPlate, ElectrodeSheet
-        
-        plate = MaterialPlate(
-            name=resource_id,
-            size_x=config.get("size_x", 80.0),
-            size_y=config.get("size_y", 80.0),
-            size_z=config.get("size_z", 10.0),
-            hole_diameter=config.get("hole_diameter", 15.0),
-            hole_depth=config.get("hole_depth", 8.0),
-            hole_spacing_x=config.get("hole_spacing_x", 20.0),
-            hole_spacing_y=config.get("hole_spacing_y", 20.0),
-            number=data.get("number", "")
-        )
-        plate.location = location
-        
-        # 如果有预填充的极片数据，创建极片
-        electrode_sheets = data.get("electrode_sheets", [])
-        for i, sheet_data in enumerate(electrode_sheets):
-            if i < len(plate.children):  # 确保不超过洞位数量
-                hole = plate.children[i]
-                sheet = ElectrodeSheet(
-                    name=f"{resource_id}_sheet_{i}",
-                    diameter=sheet_data.get("diameter", 14.0),
-                    thickness=sheet_data.get("thickness", 0.1),
-                    mass=sheet_data.get("mass", 0.01),
-                    material_type=sheet_data.get("material_type", "cathode"),
-                    info=sheet_data.get("info", "")
-                )
-                hole.place_electrode_sheet(sheet)
-        
-        return plate
-
-    def _create_plate_slot(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建板槽位"""
-        from unilabos.device_comms.button_battery_station import PlateSlot
-        
-        slot = PlateSlot(
-            name=resource_id,
-            max_plates=config.get("max_plates", 8)
-        )
-        slot.location = location
-        return slot
-
-    def _create_clip_magazine(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建子弹夹"""
-        from unilabos.device_comms.button_battery_station import ClipMagazine
-        
-        magazine = ClipMagazine(
-            name=resource_id,
-            size_x=config.get("size_x", 150.0),
-            size_y=config.get("size_y", 100.0),
-            size_z=config.get("size_z", 50.0),
-            hole_diameter=config.get("hole_diameter", 15.0),
-            hole_depth=config.get("hole_depth", 40.0),
-            hole_spacing=config.get("hole_spacing", 25.0),
-            max_sheets_per_hole=config.get("max_sheets_per_hole", 100)
-        )
-        magazine.location = location
-        return magazine
-
-    def _create_battery_press_slot(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建电池压制槽"""
-        from unilabos.device_comms.button_battery_station import BatteryPressSlot
-        
-        slot = BatteryPressSlot(
-            name=resource_id,
-            diameter=config.get("diameter", 20.0),
-            depth=config.get("depth", 15.0)
-        )
-        slot.location = location
-        return slot
-
-    def _create_tip_box(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建枪头盒"""
-        from unilabos.device_comms.button_battery_station import TipBox64
-        
-        tip_box = TipBox64(
-            name=resource_id,
-            size_x=config.get("size_x", 127.8),
-            size_y=config.get("size_y", 85.5),
-            size_z=config.get("size_z", 60.0),
-            with_tips=data.get("with_tips", True)
-        )
-        tip_box.location = location
-        return tip_box
-
-    def _create_waste_tip_box(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建废枪头盒"""
-        from unilabos.device_comms.button_battery_station import WasteTipBox
-        
-        waste_box = WasteTipBox(
-            name=resource_id,
-            size_x=config.get("size_x", 127.8),
-            size_y=config.get("size_y", 85.5),
-            size_z=config.get("size_z", 60.0),
-            max_tips=config.get("max_tips", 100)
-        )
-        waste_box.location = location
-        return waste_box
-
-    def _create_bottle_rack(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建瓶架"""
-        from unilabos.device_comms.button_battery_station import BottleRack
-        
-        rack = BottleRack(
-            name=resource_id,
-            size_x=config.get("size_x", 210.0),
-            size_y=config.get("size_y", 140.0),
-            size_z=config.get("size_z", 100.0),
-            bottle_diameter=config.get("bottle_diameter", 30.0),
-            bottle_height=config.get("bottle_height", 100.0),
-            position_spacing=config.get("position_spacing", 35.0)
-        )
-        rack.location = location
-        return rack
-
-    def _create_battery(self, resource_id: str, config: Dict[str, Any], data: Dict[str, Any], location: PLRCoordinate):
-        """创建电池"""
-        from unilabos.device_comms.button_battery_station import Battery
-        
-        battery = Battery(
-            name=resource_id,
-            diameter=config.get("diameter", 20.0),
-            height=config.get("height", 3.2),
-            max_volume=config.get("max_volume", 100.0),
-            barcode=data.get("barcode", "")
-        )
-        battery.location = location
-        return battery
-
-    # ============ 纽扣电池特定查找方法 ============
-    
-    def find_material_plates(self):
-        """查找所有料板"""
-        from unilabos.device_comms.button_battery_station import MaterialPlate
-        return self.resource_tracker.find_by_type(MaterialPlate)
-    
-    def find_batteries(self):
-        """查找所有电池"""
-        from unilabos.device_comms.button_battery_station import Battery
-        return self.resource_tracker.find_by_type(Battery)
-    
-    def find_electrode_sheets(self):
-        """查找所有极片"""
-        found = []
-        plates = self.find_material_plates()
-        for plate in plates:
-            for hole in plate.children:
-                if hasattr(hole, 'has_electrode_sheet') and hole.has_electrode_sheet():
-                    found.append(hole._electrode_sheet)
-        return found
-    
-    def find_plate_slots(self):
-        """查找所有板槽位"""
-        from unilabos.device_comms.button_battery_station import PlateSlot
-        return self.resource_tracker.find_by_type(PlateSlot)
-    
-    def find_clip_magazines(self):
-        """查找所有子弹夹"""
-        from unilabos.device_comms.button_battery_station import ClipMagazine
-        return self.resource_tracker.find_by_type(ClipMagazine)
-    
-    def find_press_slots(self):
-        """查找所有压制槽"""
-        from unilabos.device_comms.button_battery_station import BatteryPressSlot
-        return self.resource_tracker.find_by_type(BatteryPressSlot)

unilabos/registry/devices/characterization_chromatic.yaml

@@ -1,231 +1,3 @@
-hplc.agilent:
-  category:
-  - characterization_chromatic
-  class:
-    action_value_mappings:
-      auto-check_status:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 检查安捷伦HPLC设备状态的函数。用于监控设备的运行状态、连接状态、错误信息等关键指标。该函数定期查询设备状态，确保系统稳定运行，及时发现和报告设备异常。适用于自动化流程中的设备监控、故障诊断、系统维护等场景。
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: check_status参数
-          type: object
-        type: UniLabJsonCommand
-      auto-extract_data_from_txt:
-        feedback: {}
-        goal: {}
-        goal_default:
-          file_path: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 从文本文件中提取分析数据的函数。用于解析安捷伦HPLC生成的结果文件，提取峰面积、保留时间、浓度等关键分析数据。支持多种文件格式的自动识别和数据结构化处理，为后续数据分析和报告生成提供标准化的数据格式。适用于批量数据处理、结果验证、质量控制等分析工作流程。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                file_path:
-                  type: string
-              required:
-              - file_path
-              type: object
-            result: {}
-          required:
-          - goal
-          title: extract_data_from_txt参数
-          type: object
-        type: UniLabJsonCommand
-      auto-start_sequence:
-        feedback: {}
-        goal: {}
-        goal_default:
-          params: null
-          resource: null
-          wf_name: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 启动安捷伦HPLC分析序列的函数。用于执行预定义的分析方法序列，包括样品进样、色谱分离、检测等完整的分析流程。支持参数配置、资源分配、工作流程管理等功能，实现全自动的样品分析。适用于批量样品处理、标准化分析、质量检测等需要连续自动分析的应用场景。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                params:
-                  type: string
-                resource:
-                  type: object
-                wf_name:
-                  type: string
-              required:
-              - wf_name
-              type: object
-            result: {}
-          required:
-          - goal
-          title: start_sequence参数
-          type: object
-        type: UniLabJsonCommand
-      auto-try_close_sub_device:
-        feedback: {}
-        goal: {}
-        goal_default:
-          device_name: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 尝试关闭HPLC子设备的函数。用于安全地关闭泵、检测器、进样器等各个子模块，确保设备正常断开连接并保护硬件安全。该函数提供错误处理和状态确认机制，避免强制关闭可能造成的设备损坏。适用于设备维护、系统重启、紧急停机等需要安全关闭设备的场景。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                device_name:
-                  type: string
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: try_close_sub_device参数
-          type: object
-        type: UniLabJsonCommand
-      auto-try_open_sub_device:
-        feedback: {}
-        goal: {}
-        goal_default:
-          device_name: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 尝试打开HPLC子设备的函数。用于初始化和连接泵、检测器、进样器等各个子模块，建立设备通信并进行自检。该函数提供连接验证和错误恢复机制，确保子设备正常启动并准备就绪。适用于设备初始化、系统启动、设备重连等需要建立设备连接的场景。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                device_name:
-                  type: string
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: try_open_sub_device参数
-          type: object
-        type: UniLabJsonCommand
-      execute_command_from_outer:
-        feedback: {}
-        goal:
-          command: command
-        goal_default:
-          command: ''
-        handles: {}
-        result:
-          success: success
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties:
-                status:
-                  type: string
-              required:
-              - status
-              title: SendCmd_Feedback
-              type: object
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              title: SendCmd_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: SendCmd_Result
-              type: object
-          required:
-          - goal
-          title: SendCmd
-          type: object
-        type: SendCmd
-    module: unilabos.devices.hplc.AgilentHPLC:HPLCDriver
-    status_types:
-      could_run: bool
-      data_file: String
-      device_status: str
-      driver_init_ok: bool
-      finish_status: str
-      is_running: bool
-      status_text: str
-      success: bool
-    type: python
-  config_info: []
-  description: 安捷伦高效液相色谱（HPLC）分析设备，用于复杂化合物的分离、检测和定量分析。该设备通过UI自动化技术控制安捷伦ChemStation软件，实现全自动的样品分析流程。具备序列启动、设备状态监控、数据文件提取、结果处理等功能。支持多样品批量处理和实时状态反馈，适用于药物分析、环境检测、食品安全、化学研究等需要高精度色谱分析的实验室应用。
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        driver_debug:
-          default: false
-          type: string
-      required: []
-      type: object
-    data:
-      properties:
-        could_run:
-          type: boolean
-        data_file:
-          items:
-            type: string
-          type: array
-        device_status:
-          type: string
-        driver_init_ok:
-          type: boolean
-        finish_status:
-          type: string
-        is_running:
-          type: boolean
-        status_text:
-          type: string
-        success:
-          type: boolean
-      required:
-      - status_text
-      - device_status
-      - could_run
-      - driver_init_ok
-      - is_running
-      - success
-      - finish_status
-      - data_file
-      type: object
-  version: 1.0.0
 hplc.agilent-zhida:
   category:
   - characterization_chromatic

unilabos/registry/devices/characterization_optic.yaml

@@ -1,194 +1 @@
-raman.home_made:
-  category:
-  - characterization_optic
-  class:
-    action_value_mappings:
-      auto-ccd_time:
-        feedback: {}
-        goal: {}
-        goal_default:
-          int_time: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 设置CCD检测器积分时间的函数。用于配置拉曼光谱仪的信号采集时间，控制光谱数据的质量和信噪比。较长的积分时间可获得更高的信号强度和更好的光谱质量，但会增加测量时间。该函数允许根据样品特性和测量要求动态调整检测参数，优化测量效果。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                int_time:
-                  type: string
-              required:
-              - int_time
-              type: object
-            result: {}
-          required:
-          - goal
-          title: ccd_time参数
-          type: object
-        type: UniLabJsonCommand
-      auto-laser_on_power:
-        feedback: {}
-        goal: {}
-        goal_default:
-          output_voltage_laser: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 设置激光器输出功率的函数。用于控制拉曼光谱仪激光器的功率输出，调节激光强度以适应不同样品的测量需求。适当的激光功率能够获得良好的拉曼信号同时避免样品损伤。该函数支持精确的功率控制，确保测量结果的稳定性和重现性。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                output_voltage_laser:
-                  type: string
-              required:
-              - output_voltage_laser
-              type: object
-            result: {}
-          required:
-          - goal
-          title: laser_on_power参数
-          type: object
-        type: UniLabJsonCommand
-      auto-raman_without_background:
-        feedback: {}
-        goal: {}
-        goal_default:
-          int_time: null
-          laser_power: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 执行无背景扣除的拉曼光谱测量函数。用于直接采集样品的拉曼光谱信号，不进行背景校正处理。该函数配置积分时间和激光功率参数，获取原始光谱数据用于后续的数据处理分析。适用于对光谱数据质量要求较高或需要自定义背景处理流程的测量场景。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                int_time:
-                  type: string
-                laser_power:
-                  type: string
-              required:
-              - int_time
-              - laser_power
-              type: object
-            result: {}
-          required:
-          - goal
-          title: raman_without_background参数
-          type: object
-        type: UniLabJsonCommand
-      auto-raman_without_background_average:
-        feedback: {}
-        goal: {}
-        goal_default:
-          average: null
-          int_time: null
-          laser_power: null
-          sample_name: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 执行多次平均的无背景拉曼光谱测量函数。通过多次测量取平均值来提高光谱数据的信噪比和测量精度，减少随机噪声影响。该函数支持自定义平均次数、积分时间、激光功率等参数，并可为样品指定名称便于数据管理。适用于对测量精度要求较高的定量分析和研究应用。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                average:
-                  type: string
-                int_time:
-                  type: string
-                laser_power:
-                  type: string
-                sample_name:
-                  type: string
-              required:
-              - sample_name
-              - int_time
-              - laser_power
-              - average
-              type: object
-            result: {}
-          required:
-          - goal
-          title: raman_without_background_average参数
-          type: object
-        type: UniLabJsonCommand
-      raman_cmd:
-        feedback: {}
-        goal:
-          command: command
-        goal_default:
-          command: ''
-        handles: {}
-        result:
-          success: success
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties:
-                status:
-                  type: string
-              required:
-              - status
-              title: SendCmd_Feedback
-              type: object
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              title: SendCmd_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: SendCmd_Result
-              type: object
-          required:
-          - goal
-          title: SendCmd
-          type: object
-        type: SendCmd
-    module: unilabos.devices.raman_uv.home_made_raman:RamanObj
-    status_types: {}
-    type: python
-  config_info: []
-  description: 拉曼光谱分析设备，用于物质的分子结构和化学成分表征。该设备集成激光器和CCD检测器，通过串口通信控制激光功率和光谱采集。具备背景扣除、多次平均、自动数据处理等功能，支持高精度的拉曼光谱测量。适用于材料表征、化学分析、质量控制、研究开发等需要分子指纹识别和结构分析的实验应用。
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        baudrate_ccd:
-          default: 921600
-          type: string
-        baudrate_laser:
-          default: 9600
-          type: string
-        port_ccd:
-          type: string
-        port_laser:
-          type: string
-      required:
-      - port_laser
-      - port_ccd
-      type: object
-    data:
-      properties: {}
-      required: []
-      type: object
-  version: 1.0.0
+{}

unilabos/registry/devices/coin_cell_workstation.yaml

@@ -0,0 +1,586 @@
+coincellassemblyworkstation_device:
+  category:
+  - coin_cell_workstation
+  class:
+    action_value_mappings:
+      auto-change_hole_sheet_to_2:
+        feedback: {}
+        goal: {}
+        goal_default:
+          hole: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                hole:
+                  type: object
+              required:
+              - hole
+              type: object
+            result: {}
+          required:
+          - goal
+          title: change_hole_sheet_to_2参数
+          type: object
+        type: UniLabJsonCommandAsync
+      auto-fill_plate:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: fill_plate参数
+          type: object
+        type: UniLabJsonCommandAsync
+      auto-fun_wuliao_test:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: fun_wuliao_test参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_allpack_cmd:
+        feedback: {}
+        goal: {}
+        goal_default:
+          assembly_pressure: 4200
+          assembly_type: 7
+          elec_num: null
+          elec_use_num: null
+          elec_vol: 50
+          file_path: /Users/sml/work
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                assembly_pressure:
+                  default: 4200
+                  type: integer
+                assembly_type:
+                  default: 7
+                  type: integer
+                elec_num:
+                  type: string
+                elec_use_num:
+                  type: string
+                elec_vol:
+                  default: 50
+                  type: integer
+                file_path:
+                  default: /Users/sml/work
+                  type: string
+              required:
+              - elec_num
+              - elec_use_num
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_allpack_cmd参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_get_csv_export_status:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_get_csv_export_status参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_device_auto:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_device_auto参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_device_init:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_device_init参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_device_start:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_device_start参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_device_stop:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_device_stop参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_get_msg_cmd:
+        feedback: {}
+        goal: {}
+        goal_default:
+          file_path: D:\coin_cell_data
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                file_path:
+                  default: D:\coin_cell_data
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_get_msg_cmd参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_send_bottle_num:
+        feedback: {}
+        goal: {}
+        goal_default:
+          bottle_num: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                bottle_num:
+                  type: string
+              required:
+              - bottle_num
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_send_bottle_num参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_send_finished_cmd:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_send_finished_cmd参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_pack_send_msg_cmd:
+        feedback: {}
+        goal: {}
+        goal_default:
+          assembly_pressure: null
+          assembly_type: null
+          elec_use_num: null
+          elec_vol: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                assembly_pressure:
+                  type: string
+                assembly_type:
+                  type: string
+                elec_use_num:
+                  type: string
+                elec_vol:
+                  type: string
+              required:
+              - elec_use_num
+              - elec_vol
+              - assembly_type
+              - assembly_pressure
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_pack_send_msg_cmd参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_read_data_and_output:
+        feedback: {}
+        goal: {}
+        goal_default:
+          file_path: /Users/sml/work
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                file_path:
+                  default: /Users/sml/work
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_read_data_and_output参数
+          type: object
+        type: UniLabJsonCommand
+      auto-func_stop_read_data:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: func_stop_read_data参数
+          type: object
+        type: UniLabJsonCommand
+      auto-modify_deck_name:
+        feedback: {}
+        goal: {}
+        goal_default:
+          resource_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                resource_name:
+                  type: string
+              required:
+              - resource_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: modify_deck_name参数
+          type: object
+        type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
+      auto-qiming_coin_cell_code:
+        feedback: {}
+        goal: {}
+        goal_default:
+          battery_clean_ignore: false
+          battery_pressure: 4000
+          battery_pressure_mode: true
+          fujipian_juzhendianwei: 0
+          fujipian_panshu: null
+          gemo_juzhendianwei: 0
+          gemopanshu: 0
+          lvbodian: true
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                battery_clean_ignore:
+                  default: false
+                  type: boolean
+                battery_pressure:
+                  default: 4000
+                  type: integer
+                battery_pressure_mode:
+                  default: true
+                  type: boolean
+                fujipian_juzhendianwei:
+                  default: 0
+                  type: integer
+                fujipian_panshu:
+                  type: integer
+                gemo_juzhendianwei:
+                  default: 0
+                  type: integer
+                gemopanshu:
+                  default: 0
+                  type: integer
+                lvbodian:
+                  default: true
+                  type: boolean
+              required:
+              - fujipian_panshu
+              type: object
+            result: {}
+          required:
+          - goal
+          title: qiming_coin_cell_code参数
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinCellAssemblyWorkstation
+    status_types:
+      data_assembly_coin_cell_num: int
+      data_assembly_pressure: int
+      data_assembly_time: float
+      data_axis_x_pos: float
+      data_axis_y_pos: float
+      data_axis_z_pos: float
+      data_coin_cell_code: str
+      data_coin_num: int
+      data_electrolyte_code: str
+      data_electrolyte_volume: int
+      data_glove_box_o2_content: float
+      data_glove_box_pressure: float
+      data_glove_box_water_content: float
+      data_open_circuit_voltage: float
+      data_pole_weight: float
+      request_rec_msg_status: bool
+      request_send_msg_status: bool
+      sys_mode: str
+      sys_status: str
+    type: python
+  config_info: []
+  description: ''
+  handles: []
+  icon: koudian.webp
+  init_param_schema:
+    config:
+      properties:
+        address:
+          default: 172.16.28.102
+          type: string
+        config:
+          type: object
+        debug_mode:
+          default: false
+          type: boolean
+        deck:
+          type: string
+        port:
+          default: '502'
+          type: string
+      required: []
+      type: object
+    data:
+      properties:
+        data_assembly_coin_cell_num:
+          type: integer
+        data_assembly_pressure:
+          type: integer
+        data_assembly_time:
+          type: number
+        data_axis_x_pos:
+          type: number
+        data_axis_y_pos:
+          type: number
+        data_axis_z_pos:
+          type: number
+        data_coin_cell_code:
+          type: string
+        data_coin_num:
+          type: integer
+        data_electrolyte_code:
+          type: string
+        data_electrolyte_volume:
+          type: integer
+        data_glove_box_o2_content:
+          type: number
+        data_glove_box_pressure:
+          type: number
+        data_glove_box_water_content:
+          type: number
+        data_open_circuit_voltage:
+          type: number
+        data_pole_weight:
+          type: number
+        request_rec_msg_status:
+          type: boolean
+        request_send_msg_status:
+          type: boolean
+        sys_mode:
+          type: string
+        sys_status:
+          type: string
+      required:
+      - sys_status
+      - sys_mode
+      - request_rec_msg_status
+      - request_send_msg_status
+      - data_assembly_coin_cell_num
+      - data_assembly_time
+      - data_open_circuit_voltage
+      - data_axis_x_pos
+      - data_axis_y_pos
+      - data_axis_z_pos
+      - data_pole_weight
+      - data_assembly_pressure
+      - data_electrolyte_volume
+      - data_coin_num
+      - data_coin_cell_code
+      - data_electrolyte_code
+      - data_glove_box_pressure
+      - data_glove_box_o2_content
+      - data_glove_box_water_content
+      type: object
+  registry_type: device
+  version: 1.0.0

unilabos/registry/devices/laiyu_liquid.yaml

@@ -1361,8 +1361,7 @@ laiyu_liquid:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times:
-          - 0
+          mix_times: 0
           mix_vol: 0
           none_keys:
           - ''
@@ -1492,11 +1491,9 @@ laiyu_liquid:
                 mix_stage:
                   type: string
                 mix_times:
-                  items:
-                    maximum: 2147483647
-                    minimum: -2147483648
-                    type: integer
-                  type: array
+                  maximum: 2147483647
+                  minimum: -2147483648
+                  type: integer
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648

unilabos/registry/devices/liquid_handler.yaml

@@ -654,6 +654,31 @@ liquid_handler:
           title: iter_tips参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-set_group:
         feedback: {}
         goal: {}
@@ -3994,8 +4019,7 @@ liquid_handler:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times:
-          - 0
+          mix_times: 0
           mix_vol: 0
           none_keys:
           - ''
@@ -4151,11 +4175,9 @@ liquid_handler:
                 mix_stage:
                   type: string
                 mix_times:
-                  items:
-                    maximum: 2147483647
-                    minimum: -2147483648
-                    type: integer
-                  type: array
+                  maximum: 2147483647
+                  minimum: -2147483648
+                  type: integer
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648
@@ -5015,8 +5037,7 @@ liquid_handler.biomek:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times:
-          - 0
+          mix_times: 0
           mix_vol: 0
           none_keys:
           - ''
@@ -5159,11 +5180,9 @@ liquid_handler.biomek:
                 mix_stage:
                   type: string
                 mix_times:
-                  items:
-                    maximum: 2147483647
-                    minimum: -2147483648
-                    type: integer
-                  type: array
+                  maximum: 2147483647
+                  minimum: -2147483648
+                  type: integer
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648
@@ -6176,6 +6195,31 @@ liquid_handler.prcxi:
           title: move_to参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-run_protocol:
         feedback: {}
         goal: {}
@@ -7807,8 +7851,7 @@ liquid_handler.prcxi:
           mix_liquid_height: 0.0
           mix_rate: 0
           mix_stage: ''
-          mix_times:
-          - 0
+          mix_times: 0
           mix_vol: 0
           none_keys:
           - ''
@@ -7937,11 +7980,9 @@ liquid_handler.prcxi:
                 mix_stage:
                   type: string
                 mix_times:
-                  items:
-                    maximum: 2147483647
-                    minimum: -2147483648
-                    type: integer
-                  type: array
+                  maximum: 2147483647
+                  minimum: -2147483648
+                  type: integer
                 mix_vol:
                   maximum: 2147483647
                   minimum: -2147483648

unilabos/registry/devices/robot_linear_motion.yaml

@@ -834,174 +834,3 @@ linear_motion.toyo_xyz.sim:
     mesh: toyo_xyz
     type: device
   version: 1.0.0
-motor.iCL42:
-  category:
-  - robot_linear_motion
-  class:
-    action_value_mappings:
-      auto-execute_run_motor:
-        feedback: {}
-        goal: {}
-        goal_default:
-          mode: null
-          position: null
-          velocity: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 步进电机执行运动函数。直接执行电机运动命令，包括位置设定、速度控制和路径规划。该函数处理底层的电机控制协议，消除警告信息，设置运动参数并启动电机运行。适用于需要直接控制电机运动的应用场景。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                mode:
-                  type: string
-                position:
-                  type: number
-                velocity:
-                  type: integer
-              required:
-              - mode
-              - position
-              - velocity
-              type: object
-            result: {}
-          required:
-          - goal
-          title: execute_run_motor参数
-          type: object
-        type: UniLabJsonCommand
-      auto-init_device:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: iCL42电机设备初始化函数。建立与iCL42步进电机驱动器的串口通信连接，配置通信参数包括波特率、数据位、校验位等。该函数是电机使用前的必要步骤，确保驱动器处于可控状态并准备接收运动指令。
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: init_device参数
-          type: object
-        type: UniLabJsonCommand
-      auto-run_motor:
-        feedback: {}
-        goal: {}
-        goal_default:
-          mode: null
-          position: null
-          velocity: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: 步进电机运动控制函数。根据指定的运动模式、目标位置和速度参数控制电机运动。支持多种运动模式和精确的位置控制，自动处理运动轨迹规划和执行。该函数提供异步执行和状态反馈，确保运动的准确性和可靠性。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                mode:
-                  type: string
-                position:
-                  type: number
-                velocity:
-                  type: integer
-              required:
-              - mode
-              - position
-              - velocity
-              type: object
-            result: {}
-          required:
-          - goal
-          title: run_motor参数
-          type: object
-        type: UniLabJsonCommand
-      execute_command_from_outer:
-        feedback: {}
-        goal:
-          command: command
-        goal_default:
-          command: ''
-        handles: {}
-        result:
-          success: success
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties:
-                status:
-                  type: string
-              required:
-              - status
-              title: SendCmd_Feedback
-              type: object
-            goal:
-              properties:
-                command:
-                  type: string
-              required:
-              - command
-              title: SendCmd_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: SendCmd_Result
-              type: object
-          required:
-          - goal
-          title: SendCmd
-          type: object
-        type: SendCmd
-    module: unilabos.devices.motor.iCL42:iCL42Driver
-    status_types:
-      is_executing_run: bool
-      motor_position: int
-      success: bool
-    type: python
-  config_info: []
-  description: iCL42步进电机驱动器，用于实验室设备的精密线性运动控制。该设备通过串口通信控制iCL42型步进电机驱动器，支持多种运动模式和精确的位置、速度控制。具备位置反馈、运行状态监控和故障检测功能。适用于自动进样器、样品传送、精密定位平台等需要准确线性运动控制的实验室自动化设备。
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        device_address:
-          default: 1
-          type: integer
-        device_com:
-          default: COM9
-          type: string
-      required: []
-      type: object
-    data:
-      properties:
-        is_executing_run:
-          type: boolean
-        motor_position:
-          type: integer
-        success:
-          type: boolean
-      required:
-      - motor_position
-      - is_executing_run
-      - success
-      type: object
-  version: 1.0.0

unilabos/registry/devices/virtual_device.yaml

@@ -45,6 +45,31 @@ virtual_centrifuge:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       centrifuge:
         feedback:
           current_speed: current_speed
@@ -335,6 +360,31 @@ virtual_column:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       run_column:
         feedback:
           current_status: current_status
@@ -732,6 +782,31 @@ virtual_filter:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       filter:
         feedback:
           current_status: current_status
@@ -1358,6 +1433,31 @@ virtual_heatchill:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       heat_chill:
         feedback:
           status: status
@@ -2358,6 +2458,31 @@ virtual_rotavap:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       evaporate:
         feedback:
           current_device: current_device
@@ -2690,6 +2815,31 @@ virtual_separator:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       separate:
         feedback:
           current_status: status
@@ -3600,6 +3750,31 @@ virtual_solenoid_valve:
           title: is_closed参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-reset:
         feedback: {}
         goal: {}
@@ -4177,6 +4352,31 @@ virtual_solid_dispenser:
           title: parse_mol_string参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
     module: unilabos.devices.virtual.virtual_solid_dispenser:VirtualSolidDispenser
     status_types:
       current_reagent: str
@@ -4278,6 +4478,31 @@ virtual_stirrer:
           title: initialize参数
           type: object
         type: UniLabJsonCommandAsync
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       start_stir:
         feedback:
           status: status
@@ -4995,6 +5220,31 @@ virtual_transfer_pump:
           title: is_full参数
           type: object
         type: UniLabJsonCommand
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: object
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
       auto-pull_plunger:
         feedback: {}
         goal: {}

unilabos/registry/registry.py

@@ -708,6 +708,8 @@ class Registry:
                         for status_name, status_type in device_config["class"]["status_types"].items():
                             device_config["class"]["status_types"][status_name] = status_str_type_mapping[status_type]
                         for action_name, action_config in device_config["class"]["action_value_mappings"].items():
+                            if action_config["type"] not in action_str_type_mapping:
+                                continue
                             action_config["type"] = action_str_type_mapping[action_config["type"]]
                         # 添加内置的驱动命令动作
                         self._add_builtin_actions(device_config, device_id)

unilabos/registry/resources/bioyond/YB_bottle.yaml

@@ -0,0 +1,92 @@
+YB_20ml_fenyeping:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_20ml_fenyeping
+    type: pylabrobot
+  description: YB_20ml_fenyeping
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_5ml_fenyeping:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_5ml_fenyeping
+    type: pylabrobot
+  description: YB_5ml_fenyeping
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_jia_yang_tou_da:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_jia_yang_tou_da
+    type: pylabrobot
+  description: YB_jia_yang_tou_da
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_pei_ye_da_Bottle:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_da_Bottle
+    type: pylabrobot
+  description: YB_pei_ye_da_Bottle
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_pei_ye_xiao_Bottle:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_xiao_Bottle
+    type: pylabrobot
+  description: YB_pei_ye_xiao_Bottle
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_qiang_tou:
+  category:
+  - yb3
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_qiang_tou
+    type: pylabrobot
+  description: YB_qiang_tou
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_ye_Bottle:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  - YB_bottle
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_ye_Bottle
+    type: pylabrobot
+  description: YB_ye_Bottle
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0

unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml

@@ -0,0 +1,182 @@
+YB_100ml_yeti:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_100ml_yeti
+    type: pylabrobot
+  description: YB_100ml_yeti
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_20ml_fenyepingban:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_20ml_fenyepingban
+    type: pylabrobot
+  description: YB_20ml_fenyepingban
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_5ml_fenyepingban:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_5ml_fenyepingban
+    type: pylabrobot
+  description: YB_5ml_fenyepingban
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_6StockCarrier:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6StockCarrier
+    type: pylabrobot
+  description: YB_6StockCarrier
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_6VialCarrier:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6VialCarrier
+    type: pylabrobot
+  description: YB_6VialCarrier
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_gao_nian_ye_Bottle:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_gao_nian_ye_Bottle
+    type: pylabrobot
+  description: YB_gao_nian_ye_Bottle
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_gaonianye:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_gaonianye
+    type: pylabrobot
+  description: YB_gaonianye
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_jia_yang_tou_da_Carrier:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_jia_yang_tou_da_Carrier
+    type: pylabrobot
+  description: YB_jia_yang_tou_da_Carrier
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_peiyepingdaban:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingdaban
+    type: pylabrobot
+  description: YB_peiyepingdaban
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_peiyepingxiaoban:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingxiaoban
+    type: pylabrobot
+  description: YB_peiyepingxiaoban
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_qiang_tou_he:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_qiang_tou_he
+    type: pylabrobot
+  description: YB_qiang_tou_he
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_shi_pei_qi_kuai:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_shi_pei_qi_kuai
+    type: pylabrobot
+  description: YB_shi_pei_qi_kuai
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_ye:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_ye
+    type: pylabrobot
+  description: YB_ye_Bottle_Carrier
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+YB_ye_100ml_Bottle:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottles:YB_ye_100ml_Bottle
+    type: pylabrobot
+  description: YB_ye_100ml_Bottle
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0

unilabos/registry/resources/bioyond/bottle_carriers.yaml

@@ -1,48 +0,0 @@
-BIOYOND_PolymerStation_1BottleCarrier:
-  category:
-  - bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.bottle_carriers:BIOYOND_PolymerStation_1BottleCarrier
-    type: pylabrobot
-  description: BIOYOND_PolymerStation_1BottleCarrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-BIOYOND_PolymerStation_1FlaskCarrier:
-  category:
-  - bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.bottle_carriers:BIOYOND_PolymerStation_1FlaskCarrier
-    type: pylabrobot
-  description: BIOYOND_PolymerStation_1FlaskCarrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-BIOYOND_PolymerStation_6StockCarrier:
-  category:
-  - bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.bottle_carriers:BIOYOND_PolymerStation_6StockCarrier
-    type: pylabrobot
-  description: BIOYOND_PolymerStation_6StockCarrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-BIOYOND_PolymerStation_6VialCarrier:
-  category:
-  - bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.bottle_carriers:BIOYOND_PolymerStation_6VialCarrier
-    type: pylabrobot
-  description: BIOYOND_PolymerStation_6VialCarrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0

unilabos/registry/resources/bioyond/bottles.yaml

@@ -1,50 +0,0 @@
-BIOYOND_PolymerStation_Liquid_Vial:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Liquid_Vial
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-BIOYOND_PolymerStation_Reagent_Bottle:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Reagent_Bottle
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-BIOYOND_PolymerStation_Solid_Stock:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Solid_Stock
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-BIOYOND_PolymerStation_Solid_Vial:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Solid_Vial
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0
-BIOYOND_PolymerStation_Solution_Beaker:
-  category:
-  - bottles
-  class:
-    module: unilabos.resources.bioyond.bottles:BIOYOND_PolymerStation_Solution_Beaker
-    type: pylabrobot
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  version: 1.0.0

unilabos/registry/resources/bioyond/deck.yaml

@@ -22,3 +22,27 @@ BIOYOND_PolymerReactionStation_Deck:
   init_param_schema: {}
   registry_type: resource
   version: 1.0.0
+BIOYOND_YB_Deck:
+  category:
+  - deck
+  class:
+    module: unilabos.resources.bioyond.decks:BIOYOND_YB_Deck
+    type: pylabrobot
+  description: BIOYOND_YB_Deck
+  handles: []
+  icon: 配液站.webp
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0
+CoincellDeck:
+  category:
+  - deck
+  class:
+    module: unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck
+    type: pylabrobot
+  description: CoincellDeck
+  handles: []
+  icon: yihua.webp
+  init_param_schema: {}
+  registry_type: resource
+  version: 1.0.0

unilabos/registry/resources/organic/container.yaml

@@ -3,7 +3,7 @@ container:
   - container
   class:
     module: unilabos.resources.container:RegularContainer
-    type: unilabos
+    type: pylabrobot
   description: regular organic container
   handles:
   - data_key: fluid_in

unilabos/resources/battery/bottle_carriers.py

@@ -0,0 +1,56 @@
+from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d
+
+from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
+from unilabos.resources.bioyond.YB_bottles import (
+    YB_pei_ye_xiao_Bottle,
+)
+# 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
+
+
+def YIHUA_Electrolyte_12VialCarrier(name: str) -> BottleCarrier:
+    """12瓶载架 - 2x6布局"""
+    # 载架尺寸 (mm)
+    carrier_size_x = 120.0
+    carrier_size_y = 250.0
+    carrier_size_z = 50.0
+
+    # 瓶位尺寸
+    bottle_diameter = 35.0
+    bottle_spacing_x = 35.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (2 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (6 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=2,
+        num_items_y=6,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="Electrolyte_12VialCarrier",
+    )
+    carrier.num_items_x = 2
+    carrier.num_items_y = 6
+    carrier.num_items_z = 1
+    for i in range(12):
+        carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_vial_{i+1}")
+    return carrier

unilabos/resources/battery/electrode_sheet.py

@@ -0,0 +1,179 @@
+from typing import Any, Dict, Optional, TypedDict
+
+from pylabrobot.resources import Resource as ResourcePLR
+from pylabrobot.resources import Container
+
+
+electrode_colors = {
+    "PositiveCan": "#ff0000",
+    "PositiveElectrode": "#cc3333",
+    "NegativeCan": "#000000",
+    "NegativeElectrode": "#666666",
+    "SpringWasher": "#8b7355",
+    "FlatWasher": "a9a9a9",
+    "AluminumFoil": "#ffcccc",
+    "Battery": "#00ff00",
+}
+
+class ElectrodeSheetState(TypedDict):
+    mass: float  # 质量 (g)
+    material_type: str  # 材料类型（铜、铝、不锈钢、弹簧钢等）
+    color: str  # 材料类型对应的颜色
+
+
+class ElectrodeSheet(ResourcePLR):
+    """极片类 - 包含正负极片、隔膜、弹片、垫片、铝箔等所有片状材料"""
+
+    def __init__(
+        self,
+        name: str = "极片",
+        size_x=10,
+        size_y=10,
+        size_z=10,
+        category: str = "electrode_sheet",
+        model: Optional[str] = None,
+    ):
+        """初始化极片
+
+        Args:
+            name: 极片名称
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+            model=model,
+        )
+        self._unilabos_state: ElectrodeSheetState = ElectrodeSheetState(
+            diameter=14,
+            thickness=0.1,
+            mass=0.5,
+            material_type="copper",
+            info=None
+        )
+
+    # TODO: 这个还要不要？给self._unilabos_state赋值的？
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+    #序列化
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+
+def PositiveCan(name: str) -> ElectrodeSheet:
+    """创建正极壳"""
+    sheet = ElectrodeSheet(name=name, size_x=12, size_y=12, size_z=3.0, model="PositiveCan")
+    sheet.load_state({"material_type": "aluminum", "color": electrode_colors["PositiveCan"]})
+    return sheet
+
+
+def PositiveElectrode(name: str) -> ElectrodeSheet:
+    """创建正极片"""
+    sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.1, model="PositiveElectrode")
+    sheet.load_state({"material_type": "positive_electrode", "color": electrode_colors["PositiveElectrode"]})
+    return sheet
+
+
+def NegativeCan(name: str) -> ElectrodeSheet:
+    """创建负极壳"""
+    sheet = ElectrodeSheet(name=name, size_x=12, size_y=12, size_z=2.0, model="NegativeCan")
+    sheet.load_state({"material_type": "steel", "color": electrode_colors["NegativeCan"]})
+    return sheet
+
+
+def NegativeElectrode(name: str) -> ElectrodeSheet:
+    """创建负极片"""
+    sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.1, model="NegativeElectrode")
+    sheet.load_state({"material_type": "negative_electrode", "color": electrode_colors["NegativeElectrode"]})
+    return sheet
+
+
+def SpringWasher(name: str) -> ElectrodeSheet:
+    """创建弹片"""
+    sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.5, model="SpringWasher")
+    sheet.load_state({"material_type": "spring_steel", "color": electrode_colors["SpringWasher"]})
+    return sheet
+
+
+def FlatWasher(name: str) -> ElectrodeSheet:
+    """创建垫片"""
+    sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.2, model="FlatWasher")
+    sheet.load_state({"material_type": "steel", "color": electrode_colors["FlatWasher"]})
+    return sheet
+
+
+def AluminumFoil(name: str) -> ElectrodeSheet:
+    """创建铝箔"""
+    sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.05, model="AluminumFoil")
+    sheet.load_state({"material_type": "aluminum", "color": electrode_colors["AluminumFoil"]})
+    return sheet
+
+
+class BatteryState(TypedDict):
+    color: str  # 材料类型对应的颜色
+    electrolyte_name: str
+    data_electrolyte_code: str
+    open_circuit_voltage: float
+    assembly_pressure: float
+    electrolyte_volume: float
+
+    info: Optional[str]  # 附加信息
+
+
+class Battery(Container):
+    """电池类 - 包含组装好的电池"""
+
+    def __init__(
+        self,
+        name: str = "电池",
+        size_x=12,
+        size_y=12,
+        size_z=6,
+        category: str = "battery",
+        model: Optional[str] = None,
+    ):
+        """初始化电池
+
+        Args:
+            name: 电池名称
+            category: 类别
+            model: 型号
+        """
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            category=category,
+            model=model,
+        )
+        self._unilabos_state: BatteryState = BatteryState(
+            color=electrode_colors["Battery"],
+            electrolyte_name="无",
+            data_electrolyte_code="",
+            open_circuit_voltage=0.0,
+            assembly_pressure=0.0,
+            electrolyte_volume=0.0,
+            info=None
+        )
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """格式不变"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    #序列化
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        """格式不变"""
+        data = super().serialize_state()
+        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data

unilabos/resources/battery/magazine.py

@@ -0,0 +1,344 @@
+from typing import Dict, List, Optional, OrderedDict, Union, Callable
+import math
+
+from pylabrobot.resources.coordinate import Coordinate
+from pylabrobot.resources import Resource, ResourceStack, ItemizedResource
+from pylabrobot.resources.carrier import create_homogeneous_resources
+
+from unilabos.resources.battery.electrode_sheet import (
+    PositiveCan, PositiveElectrode,
+    NegativeCan, NegativeElectrode,
+    SpringWasher, FlatWasher,
+    AluminumFoil,
+    Battery
+)
+
+
+class Magazine(ResourceStack):
+    """子弹夹洞位类"""
+
+    def __init__(
+        self,
+        name: str,
+        direction: str = 'z',
+        resources: Optional[List[Resource]] = None,
+        max_sheets: int = 100,
+        **kwargs
+    ):
+        """初始化子弹夹洞位
+
+        Args:
+            name: 洞位名称
+            direction: 堆叠方向
+            resources: 资源列表
+            max_sheets: 最大极片数量
+        """
+        super().__init__(
+            name=name,
+            direction=direction,
+            resources=resources,
+        )
+        self.max_sheets = max_sheets
+
+    @property
+    def size_x(self) -> float:
+        return self.get_size_x()
+
+    @property
+    def size_y(self) -> float:
+        return self.get_size_y()
+
+    @property
+    def size_z(self) -> float:
+        return self.get_size_z()
+
+    def serialize(self) -> dict:
+        return {
+            **super().serialize(),
+            "size_x": self.size_x or 10.0,
+            "size_y": self.size_y or 10.0,
+            "size_z": self.size_z or 10.0,
+            "max_sheets": self.max_sheets,
+        }
+
+
+class MagazineHolder(ItemizedResource):
+    """子弹夹类 - 有多个洞位，每个洞位放多个极片"""
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        ordered_items: Optional[Dict[str, Magazine]] = None,
+        ordering: Optional[OrderedDict[str, str]] = None,
+        hole_diameter: float = 14.0,
+        hole_depth: float = 10.0,
+        max_sheets_per_hole: int = 100,
+        cross_section_type: str = "circle",
+        category: str = "magazine_holder",
+        model: Optional[str] = None,
+    ):
+        """初始化子弹夹
+
+        Args:
+            name: 子弹夹名称
+            size_x: 长度 (mm)
+            size_y: 宽度 (mm)
+            size_z: 高度 (mm)
+            hole_diameter: 洞直径 (mm)
+            hole_depth: 洞深度 (mm)
+            max_sheets_per_hole: 每个洞位最大极片数量
+            category: 类别
+            model: 型号
+        """
+
+        super().__init__(
+            name=name,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            ordered_items=ordered_items,
+            ordering=ordering,
+            category=category,
+            model=model,
+        )
+
+        # 保存洞位的直径和深度
+        self.hole_diameter = hole_diameter
+        self.hole_depth = hole_depth
+        self.max_sheets_per_hole = max_sheets_per_hole
+        self.cross_section_type = cross_section_type
+
+    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,
+            "cross_section_type": self.cross_section_type,
+        }
+
+
+def magazine_factory(
+    name: str,
+    size_x: float,
+    size_y: float,
+    size_z: float,
+    locations: List[Coordinate],
+    klasses: Optional[List[Callable[[str], str]]] = None,
+    hole_diameter: float = 14.0,
+    hole_depth: float = 10.0,
+    max_sheets_per_hole: int = 100,
+    category: str = "magazine_holder",
+    model: Optional[str] = None,
+) -> 'MagazineHolder':
+    """工厂函数：创建子弹夹
+    
+    Args:
+        name: 子弹夹名称
+        size_x: 长度 (mm)
+        size_y: 宽度 (mm)
+        size_z: 高度 (mm)
+        locations: 洞位坐标列表
+        klasses: 每个洞位中极片的类列表
+        hole_diameter: 洞直径 (mm)
+        hole_depth: 洞深度 (mm)
+        max_sheets_per_hole: 每个洞位最大极片数量
+        category: 类别
+        model: 型号
+    """
+    for loc in locations:
+        loc.x -= hole_diameter / 2
+        loc.y -= hole_diameter / 2
+
+    # 创建洞位
+    _sites = create_homogeneous_resources(
+        klass=Magazine,
+        locations=locations,
+        resource_size_x=hole_diameter,
+        resource_size_y=hole_diameter,
+        name_prefix=name,
+        max_sheets=max_sheets_per_hole,
+    )
+    
+    # 生成编号键
+    keys = [f"A{i+1}" for i in range(len(locations))]
+    sites = dict(zip(keys, _sites.values()))
+    
+    holder = MagazineHolder(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        ordered_items=sites,
+        hole_diameter=hole_diameter,
+        hole_depth=hole_depth,
+        max_sheets_per_hole=max_sheets_per_hole,
+        category=category,
+        model=model,
+    )
+
+    if klasses is not None:
+        for i, klass in enumerate(klasses):
+            hole_key = keys[i]
+            hole = holder.children[i]
+            for j in reversed(range(max_sheets_per_hole)):
+                item_name = f"{hole_key}_sheet{j+1}"
+                item = klass(name=item_name)
+                hole.assign_child_resource(item)
+    return holder
+
+
+def MagazineHolder_6_Cathode(
+    name: str,
+    size_x: float = 80.0,
+    size_y: float = 80.0,
+    size_z: float = 40.0,
+    hole_diameter: float = 14.0,
+    hole_depth: float = 10.0,
+    hole_spacing: float = 20.0,
+    max_sheets_per_hole: int = 100,
+) -> MagazineHolder:
+    """创建6孔子弹夹 - 六边形排布"""
+    center_x = size_x / 2
+    center_y = size_y / 2
+
+    locations = []
+
+    # 周围6个孔，按六边形排布
+    for i in range(6):
+        angle = i * 60 * math.pi / 180  # 每60度一个孔
+        x = center_x + hole_spacing * math.cos(angle)
+        y = center_y + hole_spacing * math.sin(angle)
+        locations.append(Coordinate(x, y, size_z - hole_depth))
+
+    return magazine_factory(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        locations=locations,
+        klasses=[FlatWasher, PositiveCan, PositiveCan, FlatWasher, PositiveCan, PositiveCan],
+        hole_diameter=hole_diameter,
+        hole_depth=hole_depth,
+        max_sheets_per_hole=max_sheets_per_hole,
+        category="magazine_holder",
+        model="MagazineHolder_6_Cathode",
+    )
+
+
+def MagazineHolder_6_Anode(
+    name: str,
+    size_x: float = 80.0,
+    size_y: float = 80.0,
+    size_z: float = 40.0,
+    hole_diameter: float = 14.0,
+    hole_depth: float = 10.0,
+    hole_spacing: float = 20.0,
+    max_sheets_per_hole: int = 100,
+) -> MagazineHolder:
+    """创建6孔子弹夹 - 六边形排布"""
+    center_x = size_x / 2
+    center_y = size_y / 2
+
+    locations = []
+
+    # 周围6个孔，按六边形排布
+    for i in range(6):
+        angle = i * 60 * math.pi / 180  # 每60度一个孔
+        x = center_x + hole_spacing * math.cos(angle)
+        y = center_y + hole_spacing * math.sin(angle)
+        locations.append(Coordinate(x, y, size_z - hole_depth))
+
+    return magazine_factory(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        locations=locations,
+        klasses=[SpringWasher, NegativeCan, NegativeCan, SpringWasher, NegativeCan, NegativeCan],
+        hole_diameter=hole_diameter,
+        hole_depth=hole_depth,
+        max_sheets_per_hole=max_sheets_per_hole,
+        category="magazine_holder",
+        model="MagazineHolder_6_Anode",
+    )
+
+
+def MagazineHolder_6_Battery(
+    name: str,
+    size_x: float = 80.0,
+    size_y: float = 80.0,
+    size_z: float = 40.0,
+    hole_diameter: float = 14.0,
+    hole_depth: float = 10.0,
+    hole_spacing: float = 20.0,
+    max_sheets_per_hole: int = 100,
+) -> MagazineHolder:
+    """创建6孔子弹夹 - 六边形排布"""
+    center_x = size_x / 2
+    center_y = size_y / 2
+
+    locations = []
+
+    # 周围6个孔，按六边形排布
+    for i in range(6):
+        angle = i * 60 * math.pi / 180  # 每60度一个孔
+        x = center_x + hole_spacing * math.cos(angle)
+        y = center_y + hole_spacing * math.sin(angle)
+        locations.append(Coordinate(x, y, size_z - hole_depth))
+
+    return magazine_factory(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        locations=locations,
+        klasses=None, # 初始化时，不放入装好的电池
+        hole_diameter=hole_diameter,
+        hole_depth=hole_depth,
+        max_sheets_per_hole=max_sheets_per_hole,
+        category="magazine_holder",
+        model="MagazineHolder_6_Battery",
+    )
+
+
+def MagazineHolder_4_Cathode(
+    name: str,
+) -> MagazineHolder:
+    """创建4孔子弹夹 - 正方形四角排布"""
+    size_x: float = 80.0
+    size_y: float = 80.0
+    size_z: float = 10.0
+    hole_diameter: float = 14.0
+    hole_depth: float = 10.0
+    hole_spacing: float = 25.0
+    max_sheets_per_hole: int = 100
+
+    # 计算4个洞位的坐标（正方形四角排布）
+    center_x = size_x / 2
+    center_y = size_y / 2
+    offset = hole_spacing / 2
+    
+    locations = [
+        Coordinate(center_x - offset, center_y - offset, size_z - hole_depth),  # 左下
+        Coordinate(center_x + offset, center_y - offset, size_z - hole_depth),  # 右下
+        Coordinate(center_x - offset, center_y + offset, size_z - hole_depth),  # 左上
+        Coordinate(center_x + offset, center_y + offset, size_z - hole_depth),  # 右上
+    ]
+    
+    return magazine_factory(
+        name=name,
+        size_x=size_x,
+        size_y=size_y,
+        size_z=size_z,
+        locations=locations,
+        klasses=[AluminumFoil, PositiveElectrode, PositiveElectrode, PositiveElectrode],
+        hole_diameter=hole_diameter,
+        hole_depth=hole_depth,
+        max_sheets_per_hole=max_sheets_per_hole,
+        category="magazine_holder",
+        model="MagazineHolder_4_Cathode",
+    )

unilabos/resources/bioyond/YB_bottle_carriers.py

@@ -0,0 +1,653 @@
+from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d
+
+from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
+from unilabos.resources.bioyond.YB_bottles import (
+    YB_jia_yang_tou_da,
+    YB_ye_Bottle,
+    YB_ye_100ml_Bottle,
+    YB_gao_nian_ye_Bottle,
+    YB_5ml_fenyeping,
+    YB_20ml_fenyeping,
+    YB_pei_ye_xiao_Bottle,
+    YB_pei_ye_da_Bottle,
+    YB_qiang_tou,
+)
+# 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
+
+
+def BIOYOND_Electrolyte_6VialCarrier(name: str) -> BottleCarrier:
+    """6瓶载架 - 2x3布局"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 50.0
+
+    # 瓶位尺寸
+    bottle_diameter = 30.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=3,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="Electrolyte_6VialCarrier",
+    )
+    carrier.num_items_x = 3
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    # for i in range(6):
+    #     carrier[i] = YB_Solid_Vial(f"{name}_vial_{i+1}")
+    return carrier
+
+
+def BIOYOND_Electrolyte_1BottleCarrier(name: str) -> BottleCarrier:
+    """1瓶载架 - 单个中央位置"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 100.0
+
+    # 烧杯尺寸
+    beaker_diameter = 80.0
+
+    # 计算中央位置
+    center_x = (carrier_size_x - beaker_diameter) / 2
+    center_y = (carrier_size_y - beaker_diameter) / 2
+    center_z = 5.0
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(center_x, center_y, center_z)],
+            resource_size_x=beaker_diameter,
+            resource_size_y=beaker_diameter,
+            name_prefix=name,
+        ),
+        model="Electrolyte_1BottleCarrier",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    # carrier[0] = YB_Solution_Beaker(f"{name}_beaker_1")
+    return carrier
+
+
+def YB_6StockCarrier(name: str) -> BottleCarrier:
+    """6瓶载架 - 2x3布局"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 50.0
+
+    # 瓶位尺寸
+    bottle_diameter = 20.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=3,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="6StockCarrier",
+    )
+    carrier.num_items_x = 3
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "A3", "B1", "B2", "B3"]  # 自定义顺序
+    # for i in range(6):
+    #     carrier[i] = YB_Solid_Stock(f"{name}_vial_{ordering[i]}")
+    return carrier
+
+
+def YB_6VialCarrier(name: str) -> BottleCarrier:
+    """6瓶载架 - 2x3布局"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 50.0
+
+    # 瓶位尺寸
+    bottle_diameter = 30.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=3,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="6VialCarrier",
+    )
+    carrier.num_items_x = 3
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "A3", "B1", "B2", "B3"]  # 自定义顺序
+    # for i in range(3):
+    #     carrier[i] = YB_Solid_Vial(f"{name}_solidvial_{ordering[i]}")
+    # for i in range(3, 6):
+    #     carrier[i] = YB_Liquid_Vial(f"{name}_liquidvial_{ordering[i]}")
+    return carrier
+
+# 1瓶载架 - 单个中央位置
+def YB_ye(name: str) -> BottleCarrier:
+    
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 20.0
+
+    # 烧杯尺寸
+    beaker_diameter = 60.0
+
+    # 计算中央位置
+    center_x = (carrier_size_x - beaker_diameter) / 2
+    center_y = (carrier_size_y - beaker_diameter) / 2
+    center_z = 5.0
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(center_x, center_y, center_z)],
+            resource_size_x=beaker_diameter,
+            resource_size_y=beaker_diameter,
+            name_prefix=name,
+        ),
+        model="YB_ye",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    carrier[0] = YB_ye_Bottle(f"{name}_flask_1")
+    return carrier
+
+
+# 高粘液瓶载架 - 单个中央位置
+def YB_gaonianye(name: str) -> BottleCarrier:
+    
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 20.0
+
+    # 烧杯尺寸
+    beaker_diameter = 60.0
+
+    # 计算中央位置
+    center_x = (carrier_size_x - beaker_diameter) / 2
+    center_y = (carrier_size_y - beaker_diameter) / 2
+    center_z = 5.0
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(center_x, center_y, center_z)],
+            resource_size_x=beaker_diameter,
+            resource_size_y=beaker_diameter,
+            name_prefix=name,
+        ),
+        model="YB_gaonianye",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    carrier[0] = YB_gao_nian_ye_Bottle(f"{name}_flask_1")
+    return carrier
+
+
+# 100ml液体瓶载架 - 单个中央位置
+def YB_100ml_yeti(name: str) -> BottleCarrier:
+    
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 20.0
+
+    # 烧杯尺寸
+    beaker_diameter = 60.0
+
+    # 计算中央位置
+    center_x = (carrier_size_x - beaker_diameter) / 2
+    center_y = (carrier_size_y - beaker_diameter) / 2
+    center_z = 5.0
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(center_x, center_y, center_z)],
+            resource_size_x=beaker_diameter,
+            resource_size_y=beaker_diameter,
+            name_prefix=name,
+        ),
+        model="YB_100ml_yeti",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    carrier[0] = YB_ye_100ml_Bottle(f"{name}_flask_1")
+    return carrier
+
+# 5ml分液瓶板 - 4x2布局，8个位置
+def YB_5ml_fenyepingban(name: str) -> BottleCarrier:
+    
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 50.0
+
+    # 瓶位尺寸
+    bottle_diameter = 15.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=4,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_5ml_fenyepingban",
+    )
+    carrier.num_items_x = 4
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
+    for i in range(8):
+        carrier[i] = YB_5ml_fenyeping(f"{name}_vial_{ordering[i]}")
+    return carrier
+
+# 20ml分液瓶板 - 4x2布局，8个位置
+def YB_20ml_fenyepingban(name: str) -> BottleCarrier:
+
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 70.0
+
+    # 瓶位尺寸
+    bottle_diameter = 20.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=4,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_20ml_fenyepingban",
+    )
+    carrier.num_items_x = 4
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
+    for i in range(8):
+        carrier[i] = YB_20ml_fenyeping(f"{name}_vial_{ordering[i]}")
+    return carrier
+
+# 配液瓶(小)板 - 4x2布局，8个位置
+def YB_peiyepingxiaoban(name: str) -> BottleCarrier:
+    
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 65.0
+
+    # 瓶位尺寸
+    bottle_diameter = 35.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=4,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_peiyepingxiaoban",
+    )
+    carrier.num_items_x = 4
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
+    for i in range(8):
+        carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_bottle_{ordering[i]}")
+    return carrier
+
+
+# 配液瓶(大)板 - 2x2布局，4个位置
+def YB_peiyepingdaban(name: str) -> BottleCarrier:
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 95.0
+
+    # 瓶位尺寸
+    bottle_diameter = 55.0
+    bottle_spacing_x = 60.0  # X方向间距
+    bottle_spacing_y = 60.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (2 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=2,
+        num_items_y=2,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_peiyepingdaban",
+    )
+    carrier.num_items_x = 2
+    carrier.num_items_y = 2
+    carrier.num_items_z = 1
+    ordering = ["A1", "A2", "B1", "B2"]
+    for i in range(4):
+        carrier[i] = YB_pei_ye_da_Bottle(f"{name}_bottle_{ordering[i]}")
+    return carrier
+
+# 加样头(大)板 - 1x1布局，1个位置
+def YB_jia_yang_tou_da_Carrier(name: str) -> BottleCarrier:
+    
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 95.0
+
+    # 瓶位尺寸
+    bottle_diameter = 35.0
+    bottle_spacing_x = 42.0  # X方向间距
+    bottle_spacing_y = 35.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (1 - 1) * bottle_spacing_x - bottle_diameter) / 2
+    start_y = (carrier_size_y - (1 - 1) * bottle_spacing_y - bottle_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=1,
+        num_items_y=1,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=bottle_spacing_x,
+        item_dy=bottle_spacing_y,
+        size_x=bottle_diameter,
+        size_y=bottle_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_jia_yang_tou_da_Carrier",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    carrier[0] = YB_jia_yang_tou_da(f"{name}_head_1")
+    return carrier
+
+
+def YB_shi_pei_qi_kuai(name: str) -> BottleCarrier:
+    """适配器块 - 单个中央位置"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 30.0
+
+    # 适配器尺寸
+    adapter_diameter = 80.0
+
+    # 计算中央位置
+    center_x = (carrier_size_x - adapter_diameter) / 2
+    center_y = (carrier_size_y - adapter_diameter) / 2
+    center_z = 0.0
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=create_homogeneous_resources(
+            klass=ResourceHolder,
+            locations=[Coordinate(center_x, center_y, center_z)],
+            resource_size_x=adapter_diameter,
+            resource_size_y=adapter_diameter,
+            name_prefix=name,
+        ),
+        model="YB_shi_pei_qi_kuai",
+    )
+    carrier.num_items_x = 1
+    carrier.num_items_y = 1
+    carrier.num_items_z = 1
+    # 适配器块本身不包含瓶子，只是一个支撑结构
+    return carrier
+
+
+def YB_qiang_tou_he(name: str) -> BottleCarrier:
+    """枪头盒 - 8x12布局，96个位置"""
+
+    # 载架尺寸 (mm)
+    carrier_size_x = 127.8
+    carrier_size_y = 85.5
+    carrier_size_z = 55.0
+
+    # 枪头尺寸
+    tip_diameter = 10.0
+    tip_spacing_x = 9.0  # X方向间距
+    tip_spacing_y = 9.0  # Y方向间距
+
+    # 计算起始位置 (居中排列)
+    start_x = (carrier_size_x - (12 - 1) * tip_spacing_x - tip_diameter) / 2
+    start_y = (carrier_size_y - (8 - 1) * tip_spacing_y - tip_diameter) / 2
+
+    sites = create_ordered_items_2d(
+        klass=ResourceHolder,
+        num_items_x=12,
+        num_items_y=8,
+        dx=start_x,
+        dy=start_y,
+        dz=5.0,
+        item_dx=tip_spacing_x,
+        item_dy=tip_spacing_y,
+        size_x=tip_diameter,
+        size_y=tip_diameter,
+        size_z=carrier_size_z,
+    )
+    for k, v in sites.items():
+        v.name = f"{name}_{v.name}"
+
+    carrier = BottleCarrier(
+        name=name,
+        size_x=carrier_size_x,
+        size_y=carrier_size_y,
+        size_z=carrier_size_z,
+        sites=sites,
+        model="YB_qiang_tou_he",
+    )
+    carrier.num_items_x = 12
+    carrier.num_items_y = 8
+    carrier.num_items_z = 1
+    # 创建96个枪头
+    for i in range(96):
+        row = chr(65 + i // 12)  # A-H
+        col = (i % 12) + 1  # 1-12
+        carrier[i] = YB_qiang_tou(f"{name}_tip_{row}{col}")
+    return carrier
+

unilabos/resources/bioyond/YB_bottles.py

@@ -0,0 +1,163 @@
+from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
+# 工厂函数
+"""加样头（大）"""
+def YB_jia_yang_tou_da(
+    name: str,
+    diameter: float = 20.0,
+    height: float = 100.0,
+    max_volume: float = 30000.0,  # 30mL
+    barcode: str = None,
+) -> Bottle:
+    """创建粉末瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,# 未知
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_jia_yang_tou_da",
+    )
+
+"""液1x1"""
+def YB_ye_Bottle(
+    name: str,
+    diameter: float = 40.0,
+    height: float = 70.0,
+    max_volume: float = 50000.0,  # 50mL
+    barcode: str = None,
+) -> Bottle:
+    """创建液体瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_ye_Bottle",
+    )
+
+"""100ml液体"""
+def YB_ye_100ml_Bottle(
+    name: str,
+    diameter: float = 50.0,
+    height: float = 90.0,
+    max_volume: float = 100000.0,  # 100mL
+    barcode: str = None,
+) -> Bottle:
+    """创建100ml液体瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_100ml_yeti",
+    )
+
+"""高粘液"""
+def YB_gao_nian_ye_Bottle(
+    name: str,
+    diameter: float = 40.0,
+    height: float = 70.0,
+    max_volume: float = 50000.0,  # 50mL
+    barcode: str = None,
+) -> Bottle:
+    """创建高粘液瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="High_Viscosity_Liquid",
+    )
+
+"""5ml分液瓶"""
+def YB_5ml_fenyeping(
+    name: str,
+    diameter: float = 20.0,
+    height: float = 50.0,
+    max_volume: float = 5000.0,  # 5mL
+    barcode: str = None,
+) -> Bottle:
+    """创建5ml分液瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_5ml_fenyeping",
+    )
+
+"""20ml分液瓶"""
+def YB_20ml_fenyeping(
+    name: str,
+    diameter: float = 30.0,
+    height: float = 65.0,
+    max_volume: float = 20000.0,  # 20mL
+    barcode: str = None,
+) -> Bottle:
+    """创建20ml分液瓶"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_20ml_fenyeping",
+    )
+
+"""配液瓶(小)"""
+def YB_pei_ye_xiao_Bottle(
+    name: str,
+    diameter: float = 35.0,
+    height: float = 60.0,
+    max_volume: float = 30000.0,  # 30mL
+    barcode: str = None,
+) -> Bottle:
+    """创建配液瓶(小)"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_pei_ye_xiao_Bottle",
+    )
+
+"""配液瓶(大)"""
+def YB_pei_ye_da_Bottle(
+    name: str,
+    diameter: float = 55.0,
+    height: float = 100.0,
+    max_volume: float = 150000.0,  # 150mL
+    barcode: str = None,
+) -> Bottle:
+    """创建配液瓶(大)"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_pei_ye_da_Bottle",
+    )
+
+"""枪头"""
+def YB_qiang_tou(
+    name: str,
+    diameter: float = 10.0,
+    height: float = 50.0,
+    max_volume: float = 1000.0,  # 1mL
+    barcode: str = None,
+) -> Bottle:
+    """创建枪头"""
+    return Bottle(
+        name=name,
+        diameter=diameter,
+        height=height,
+        max_volume=max_volume,
+        barcode=barcode,
+        model="YB_qiang_tou",
+    )    

unilabos/resources/bioyond/YB_warehouses.py

@@ -0,0 +1,209 @@
+from unilabos.resources.warehouse import WareHouse, YB_warehouse_factory
+
+
+def bioyond_warehouse_1x4x4(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=1,
+        num_items_y=4,
+        num_items_z=4,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+
+
+def bioyond_warehouse_1x4x2(name: str) -> WareHouse:
+    """创建BioYond 4x1x2仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=1,
+        num_items_y=4,
+        num_items_z=2,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+        removed_positions=None
+    )
+ # 定义benyond的堆栈
+def bioyond_warehouse_1x2x2(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=2,
+        num_items_y=2,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="YB_warehouse",
+    )
+
+def bioyond_warehouse_2x2x1(name: str) -> WareHouse:
+    """创建BioYond 2x2x1仓库（自动堆栈）"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=2,
+        num_items_y=2,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="YB_warehouse",
+    )
+
+def bioyond_warehouse_10x1x1(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=10,
+        num_items_y=1,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+def bioyond_warehouse_1x3x3(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=1,
+        num_items_y=3,
+        num_items_z=3,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+def bioyond_warehouse_2x1x3(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=2,
+        num_items_y=1,
+        num_items_z=3,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+
+def bioyond_warehouse_3x3x1(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=3,
+        num_items_y=3,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+def bioyond_warehouse_5x1x1(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=5,
+        num_items_y=1,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+def bioyond_warehouse_3x3x1_2(name: str) -> WareHouse:
+    """创建BioYond 4x1x4仓库"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=3,
+        num_items_y=3,
+        num_items_z=1,
+        dx=12.0,
+        dy=12.0,
+        dz=12.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+
+def bioyond_warehouse_liquid_and_lid_handling(name: str) -> WareHouse:
+    """创建BioYond开关盖加液模块台面"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=2,
+        num_items_y=5,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+        removed_positions=None
+    )
+
+def bioyond_warehouse_3x5x1(name: str) -> WareHouse:
+    """创建BioYond 3x5x1仓库（手动堆栈）"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=3,
+        num_items_y=5,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )
+
+def bioyond_warehouse_20x1x1(name: str) -> WareHouse:
+    """创建BioYond 20x1x1仓库（粉末加样头堆栈）"""
+    return YB_warehouse_factory(
+        name=name,
+        num_items_x=20,
+        num_items_y=1,
+        num_items_z=1,
+        dx=10.0,
+        dy=10.0,
+        dz=10.0,
+        item_dx=137.0,
+        item_dy=96.0,
+        item_dz=120.0,
+        category="warehouse",
+    )

unilabos/resources/bioyond/bottle_carriers.py

@@ -1,276 +0,0 @@
-from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d
-
-from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
-from unilabos.resources.bioyond.bottles import (
-    BIOYOND_PolymerStation_Solid_Stock,
-    BIOYOND_PolymerStation_Solid_Vial,
-    BIOYOND_PolymerStation_Liquid_Vial,
-    BIOYOND_PolymerStation_Solution_Beaker,
-    BIOYOND_PolymerStation_Reagent_Bottle
-)
-# 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
-
-
-def BIOYOND_Electrolyte_6VialCarrier(name: str) -> BottleCarrier:
-    """6瓶载架 - 2x3布局"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 50.0
-
-    # 瓶位尺寸
-    bottle_diameter = 30.0
-    bottle_spacing_x = 42.0  # X方向间距
-    bottle_spacing_y = 35.0  # Y方向间距
-
-    # 计算起始位置 (居中排列)
-    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
-    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
-
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=3,
-        num_items_y=2,
-        dx=start_x,
-        dy=start_y,
-        dz=5.0,
-        item_dx=bottle_spacing_x,
-        item_dy=bottle_spacing_y,
-
-        size_x=bottle_diameter,
-        size_y=bottle_diameter,
-        size_z=carrier_size_z,
-    )
-    for k, v in sites.items():
-        v.name = f"{name}_{v.name}"
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=sites,
-        model="BIOYOND_Electrolyte_6VialCarrier",
-    )
-    carrier.num_items_x = 3
-    carrier.num_items_y = 2
-    carrier.num_items_z = 1
-    for i in range(6):
-        carrier[i] = BIOYOND_PolymerStation_Solid_Vial(f"{name}_vial_{i+1}")
-    return carrier
-
-
-def BIOYOND_Electrolyte_1BottleCarrier(name: str) -> BottleCarrier:
-    """1瓶载架 - 单个中央位置"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 100.0
-
-    # 烧杯尺寸
-    beaker_diameter = 80.0
-
-    # 计算中央位置
-    center_x = (carrier_size_x - beaker_diameter) / 2
-    center_y = (carrier_size_y - beaker_diameter) / 2
-    center_z = 5.0
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=create_homogeneous_resources(
-            klass=ResourceHolder,
-            locations=[Coordinate(center_x, center_y, center_z)],
-            resource_size_x=beaker_diameter,
-            resource_size_y=beaker_diameter,
-            name_prefix=name,
-        ),
-        model="BIOYOND_Electrolyte_1BottleCarrier",
-    )
-    carrier.num_items_x = 1
-    carrier.num_items_y = 1
-    carrier.num_items_z = 1
-    carrier[0] = BIOYOND_PolymerStation_Solution_Beaker(f"{name}_beaker_1")
-    return carrier
-
-
-def BIOYOND_PolymerStation_6StockCarrier(name: str) -> BottleCarrier:
-    """6瓶载架 - 2x3布局"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 50.0
-
-    # 瓶位尺寸
-    bottle_diameter = 20.0
-    bottle_spacing_x = 42.0  # X方向间距
-    bottle_spacing_y = 35.0  # Y方向间距
-
-    # 计算起始位置 (居中排列)
-    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
-    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
-
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=3,
-        num_items_y=2,
-        dx=start_x,
-        dy=start_y,
-        dz=5.0,
-        item_dx=bottle_spacing_x,
-        item_dy=bottle_spacing_y,
-
-        size_x=bottle_diameter,
-        size_y=bottle_diameter,
-        size_z=carrier_size_z,
-    )
-    for k, v in sites.items():
-        v.name = f"{name}_{v.name}"
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=sites,
-        model="BIOYOND_PolymerStation_6VialCarrier",
-    )
-    carrier.num_items_x = 3
-    carrier.num_items_y = 2
-    carrier.num_items_z = 1
-    ordering = ["A1", "A2", "A3", "B1", "B2", "B3"]  # 自定义顺序
-    for i in range(6):
-        carrier[i] = BIOYOND_PolymerStation_Solid_Stock(f"{name}_vial_{ordering[i]}")
-    return carrier
-
-
-def BIOYOND_PolymerStation_6VialCarrier(name: str) -> BottleCarrier:
-    """6瓶载架 - 2x3布局"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 50.0
-
-    # 瓶位尺寸
-    bottle_diameter = 30.0
-    bottle_spacing_x = 42.0  # X方向间距
-    bottle_spacing_y = 35.0  # Y方向间距
-
-    # 计算起始位置 (居中排列)
-    start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2
-    start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2
-
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=3,
-        num_items_y=2,
-        dx=start_x,
-        dy=start_y,
-        dz=5.0,
-        item_dx=bottle_spacing_x,
-        item_dy=bottle_spacing_y,
-
-        size_x=bottle_diameter,
-        size_y=bottle_diameter,
-        size_z=carrier_size_z,
-    )
-    for k, v in sites.items():
-        v.name = f"{name}_{v.name}"
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=sites,
-        model="BIOYOND_PolymerStation_6VialCarrier",
-    )
-    carrier.num_items_x = 3
-    carrier.num_items_y = 2
-    carrier.num_items_z = 1
-    ordering = ["A1", "A2", "A3", "B1", "B2", "B3"]  # 自定义顺序
-    for i in range(3):
-        carrier[i] = BIOYOND_PolymerStation_Solid_Vial(f"{name}_solidvial_{ordering[i]}")
-    for i in range(3, 6):
-        carrier[i] = BIOYOND_PolymerStation_Liquid_Vial(f"{name}_liquidvial_{ordering[i]}")
-    return carrier
-
-
-def BIOYOND_PolymerStation_1BottleCarrier(name: str) -> BottleCarrier:
-    """1瓶载架 - 单个中央位置"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 20.0
-
-    # 烧杯尺寸
-    beaker_diameter = 60.0
-
-    # 计算中央位置
-    center_x = (carrier_size_x - beaker_diameter) / 2
-    center_y = (carrier_size_y - beaker_diameter) / 2
-    center_z = 5.0
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=create_homogeneous_resources(
-            klass=ResourceHolder,
-            locations=[Coordinate(center_x, center_y, center_z)],
-            resource_size_x=beaker_diameter,
-            resource_size_y=beaker_diameter,
-            name_prefix=name,
-        ),
-        model="BIOYOND_PolymerStation_1BottleCarrier",
-    )
-    carrier.num_items_x = 1
-    carrier.num_items_y = 1
-    carrier.num_items_z = 1
-    carrier[0] = BIOYOND_PolymerStation_Reagent_Bottle(f"{name}_flask_1")
-    return carrier
-
-
-def BIOYOND_PolymerStation_1FlaskCarrier(name: str) -> BottleCarrier:
-    """1瓶载架 - 单个中央位置"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 20.0
-
-    # 烧杯尺寸
-    beaker_diameter = 70.0
-
-    # 计算中央位置
-    center_x = (carrier_size_x - beaker_diameter) / 2
-    center_y = (carrier_size_y - beaker_diameter) / 2
-    center_z = 5.0
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=create_homogeneous_resources(
-            klass=ResourceHolder,
-            locations=[Coordinate(center_x, center_y, center_z)],
-            resource_size_x=beaker_diameter,
-            resource_size_y=beaker_diameter,
-            name_prefix=name,
-        ),
-        model="BIOYOND_PolymerStation_1FlaskCarrier",
-    )
-    carrier.num_items_x = 1
-    carrier.num_items_y = 1
-    carrier.num_items_z = 1
-    carrier[0] = BIOYOND_PolymerStation_Reagent_Bottle(f"{name}_bottle_1")
-    return carrier