try build

Co-authored-by: quehh <scienceol@outlook.com>

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

@@ -0,0 +1,122 @@
+name: Multi-Platform Conda Build
+
+on:
+  push:
+    branches: [ main, dev ]
+    tags: [ 'v*' ]
+  pull_request:
+    branches: [ main, dev ]
+  workflow_dispatch:
+    inputs:
+      platforms:
+        description: '选择构建平台 (逗号分隔): linux-64, osx-64, osx-arm64, win-64'
+        required: false
+        default: 'osx-arm64'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - os: ubuntu-latest
+          platform: linux-64
+          env_file: unilabos-linux-64.yaml
+        - os: macos-13 # Intel
+          platform: osx-64
+          env_file: unilabos-osx-64.yaml
+        - os: macos-latest # ARM64
+          platform: osx-arm64
+          env_file: unilabos-osx-arm64.yaml
+        - os: windows-latest
+          platform: win-64
+          env_file: unilabos-win64.yaml
+
+    runs-on: ${{ matrix.os }}
+
+    defaults:
+      run:
+        shell: bash -l {0}
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Check if platform should be built
+      id: should_build
+      run: |
+        if [[ "${{ github.event_name }}" != "workflow_dispatch" ]]; then
+          echo "should_build=true" >> $GITHUB_OUTPUT
+        elif [[ -z "${{ github.event.inputs.platforms }}" ]]; then
+          echo "should_build=true" >> $GITHUB_OUTPUT
+        elif [[ "${{ github.event.inputs.platforms }}" == *"${{ matrix.platform }}"* ]]; then
+          echo "should_build=true" >> $GITHUB_OUTPUT
+        else
+          echo "should_build=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Setup Miniconda
+      if: steps.should_build.outputs.should_build == 'true'
+      uses: conda-incubator/setup-miniconda@v3
+      with:
+        miniconda-version: "latest"
+        channels: conda-forge,robostack-staging,defaults
+        channel-priority: strict
+        activate-environment: build-env
+        auto-activate-base: false
+        auto-update-conda: false
+        show-channel-urls: true
+
+    - name: Install boa and build tools
+      if: steps.should_build.outputs.should_build == 'true'
+      run: |
+        conda install -c conda-forge boa conda-build
+
+    - name: Show environment info
+      if: steps.should_build.outputs.should_build == 'true'
+      run: |
+        conda info
+        conda list | grep -E "(boa|conda-build)"
+        echo "Platform: ${{ matrix.platform }}"
+        echo "OS: ${{ matrix.os }}"
+
+    - name: Build conda package
+      if: steps.should_build.outputs.should_build == 'true'
+      run: |
+        if [[ "${{ matrix.platform }}" == "osx-arm64" ]]; then
+          boa build -m ./recipes/conda_build_config.yaml -m ./recipes/macos_sdk_config.yaml ./recipes/ros-humble-unilabos-msgs
+        else
+          boa build -m ./recipes/conda_build_config.yaml ./recipes/ros-humble-unilabos-msgs
+        fi
+
+    - name: List built packages
+      if: steps.should_build.outputs.should_build == 'true'
+      run: |
+        echo "Built packages in conda-bld:"
+        find $CONDA_PREFIX/conda-bld -name "*.tar.bz2" | head -10
+        ls -la $CONDA_PREFIX/conda-bld/${{ matrix.platform }}/ || echo "${{ matrix.platform }} directory not found"
+        ls -la $CONDA_PREFIX/conda-bld/noarch/ || echo "noarch directory not found"
+
+    - name: Upload conda package artifacts
+      if: steps.should_build.outputs.should_build == 'true'
+      uses: actions/upload-artifact@v4
+      with:
+        name: conda-package-${{ matrix.platform }}
+        path: ${{ env.CONDA_PREFIX }}/conda-bld/**/*.tar.bz2
+        if-no-files-found: warn
+        retention-days: 30
+
+    - name: Create release assets (on tags)
+      if: steps.should_build.outputs.should_build == 'true' && startsWith(github.ref, 'refs/tags/')
+      run: |
+        mkdir -p release-assets
+        find $CONDA_PREFIX/conda-bld -name "*.tar.bz2" -exec cp {} release-assets/ \;
+
+    - name: Upload to release
+      if: steps.should_build.outputs.should_build == 'true' && startsWith(github.ref, 'refs/tags/')
+      uses: softprops/action-gh-release@v1
+      with:
+        files: release-assets/*
+        draft: false
+        prerelease: false

MANIFEST.in

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

README.md

@@ -49,7 +49,7 @@ conda env update --file unilabos-[YOUR_OS].yml -n environment_name
 
 # Currently, you need to install the `unilabos_msgs` package
 # You can download the system-specific package from the Release page
-conda install ros-humble-unilabos-msgs-0.9.4-xxxxx.tar.bz2
+conda install ros-humble-unilabos-msgs-0.9.5-xxxxx.tar.bz2
 
 # Install PyLabRobot and other prerequisites
 git clone https://github.com/PyLabRobot/pylabrobot plr_repo

README_zh.md

@@ -49,7 +49,7 @@ conda env update --file unilabos-[YOUR_OS].yml -n 环境名
 
 # 现阶段，需要安装 `unilabos_msgs` 包
 # 可以前往 Release 页面下载系统对应的包进行安装
-conda install ros-humble-unilabos-msgs-0.9.4-xxxxx.tar.bz2
+conda install ros-humble-unilabos-msgs-0.9.5-xxxxx.tar.bz2
 
 # 安装PyLabRobot等前置
 git clone https://github.com/PyLabRobot/pylabrobot plr_repo

recipes/macos_sdk_config.yaml

@@ -0,0 +1,7 @@
+CONDA_BUILD_SYSROOT:
+  - /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
+MACOSX_DEPLOYMENT_TARGET:
+  - "11.0"
+CONDA_SUBDIR:
+  - osx-arm64
+# boa build -m ./recipes/conda_build_config.yaml -m ./recipes/macos_sdk_config.yaml ./recipes/ros-humble-unilabos-msgs

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

@@ -1,6 +1,6 @@
 package:
   name: ros-humble-unilabos-msgs
-  version: 0.9.4
+  version: 0.9.5
 source:
   path: ../../unilabos_msgs
   folder: ros-humble-unilabos-msgs/src/work

recipes/unilabos/recipe.yaml

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

setup.py

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

unilabos/compile/pump_protocol.py

@@ -2,17 +2,42 @@ import numpy as np
 import networkx as nx
 
 
+def is_integrated_pump(node_name):
+    return "pump" in node_name and "valve" in node_name
+
+
+def find_connected_pump(G, valve_node):
+    for neighbor in G.neighbors(valve_node):
+        if "pump" in G.nodes[neighbor]["class"]:
+            return neighbor
+    raise ValueError(f"未找到与阀 {valve_node} 唯一相连的泵节点")
+
+
+def build_pump_valve_maps(G, pump_backbone):
+    pumps_from_node = {}
+    valve_from_node = {}
+    for node in pump_backbone:
+        if is_integrated_pump(node):
+            pumps_from_node[node] = node
+            valve_from_node[node] = node
+        else:
+            pump_node = find_connected_pump(G, node)
+            pumps_from_node[node] = pump_node
+            valve_from_node[node] = node
+    return pumps_from_node, valve_from_node
+
+
 def generate_pump_protocol(
-    G: nx.DiGraph, 
+        G: nx.DiGraph,
-    from_vessel: str, 
+        from_vessel: str,
-    to_vessel: str, 
+        to_vessel: str,
-    volume: float, 
+        volume: float,
-    flowrate: float = 0.5,
+        flowrate: float = 0.5,
-    transfer_flowrate: float = 0, 
+        transfer_flowrate: float = 0,
 ) -> list[dict]:
     """
     生成泵操作的动作序列。
-    
+
     :param G: 有向图, 节点为容器和注射泵, 边为流体管道, A→B边的属性为管道接A端的阀门位置
     :param from_vessel: 容器A
     :param to_vessel: 容器B
@@ -21,194 +46,137 @@ def generate_pump_protocol(
     :param transfer_flowrate: 泵骨架中转移流速（若不指定，默认与注入流速相同）
     :return: 泵操作的动作序列
     """
-    
+
     # 生成泵操作的动作序列
     pump_action_sequence = []
-    
+    nodes = G.nodes(data=True)
-    # 检查节点是否存在
+    # 从from_vessel到to_vessel的最短路径
-    if from_vessel not in G.nodes:
+    shortest_path = nx.shortest_path(G, source=from_vessel, target=to_vessel)
-        print(f"Warning: Source vessel '{from_vessel}' not found in graph. Skipping.")
+    print(shortest_path)
-        return []
-    
-    if to_vessel not in G.nodes:
-        print(f"Warning: Target vessel '{to_vessel}' not found in graph. Skipping.")
-        return []
-    
-    # 检查是否存在路径
-    try:
-        shortest_path = nx.shortest_path(G, source=from_vessel, target=to_vessel)
-    except nx.NetworkXNoPath:
-        print(f"Warning: No path from '{from_vessel}' to '{to_vessel}'. Skipping.")
-        return []
-    except nx.NodeNotFound as e:
-        print(f"Warning: Node not found: {e}. Skipping.")
-        return []
-    
-    print(f"Shortest path: {shortest_path}")
 
     pump_backbone = shortest_path
     if not from_vessel.startswith("pump"):
         pump_backbone = pump_backbone[1:]
     if not to_vessel.startswith("pump"):
         pump_backbone = pump_backbone[:-1]
-    
+
-    print(f"Pump backbone: {pump_backbone}")
-    
-    # 修复：检查pump_backbone是否为空
-    if not pump_backbone:
-        print(f"Warning: No pumps found in path from '{from_vessel}' to '{to_vessel}'. Skipping.")
-        return []
-    
     if transfer_flowrate == 0:
         transfer_flowrate = flowrate
-    
+
-    # 修复：正确访问节点数据
+    pumps_from_node, valve_from_node = build_pump_valve_maps(G, pump_backbone)
-    pump_max_volumes = []
+
-    for pump in pump_backbone:
+    min_transfer_volume = min([nodes[pumps_from_node[node]]["config"]["max_volume"] for node in pump_backbone])
-        # 直接使用 G.nodes[pump] 来访问节点数据
-        pump_data = G.nodes[pump] if pump in G.nodes else {}
-        # 尝试多种可能的键名，并提供默认值
-        max_vol = pump_data.get('max_volume') or pump_data.get('max_vol') or pump_data.get('volume')
-        if max_vol is None:
-            # 如果是设备节点，尝试从config中获取
-            config = pump_data.get('config', {})
-            max_vol = config.get('max_volume', 25.0)
-        pump_max_volumes.append(float(max_vol))
-    
-    if pump_max_volumes:
-        min_transfer_volume = min(pump_max_volumes)
-    else:
-        min_transfer_volume = 25.0  # 默认值
-    
     repeats = int(np.ceil(volume / min_transfer_volume))
     if repeats > 1 and (from_vessel.startswith("pump") or to_vessel.startswith("pump")):
         raise ValueError("Cannot transfer volume larger than min_transfer_volume between two pumps.")
-    
+
     volume_left = volume
-    
+
     # 生成泵操作的动作序列
     for i in range(repeats):
         # 单泵依次执行阀指令、活塞指令，将液体吸入与之相连的第一台泵
-        if not from_vessel.startswith("pump") and pump_backbone:
+        if not from_vessel.startswith("pump"):
-            # 修复：添加边缘数据检查
+            pump_action_sequence.extend([
-            edge_data = G.get_edge_data(pump_backbone[0], from_vessel)
+                {
-            if edge_data and "port" in edge_data:
+                    "device_id": valve_from_node[pump_backbone[0]],
-                pump_action_sequence.extend([
+                    "action_name": "set_valve_position",
-                    {
+                    "action_kwargs": {
-                        "device_id": pump_backbone[0], 
+                        "command": G.get_edge_data(pump_backbone[0], from_vessel)["port"][pump_backbone[0]]
-                        "action_name": "set_valve_position",
-                        "action_kwargs": {
-                            "command": edge_data["port"][pump_backbone[0]]
-                        }
-                    },
-                    {
-                        "device_id": pump_backbone[0], 
-                        "action_name": "set_position",
-                        "action_kwargs": {
-                            "position": float(min(volume_left, min_transfer_volume)),
-                            "max_velocity": transfer_flowrate
-                        }
                     }
-                ])
+                },
-                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
+                {
-            else:
+                    "device_id": pumps_from_node[pump_backbone[0]],
-                print(f"Warning: No edge data found between {pump_backbone[0]} and {from_vessel}")
+                    "action_name": "set_position",
-        
+                    "action_kwargs": {
-        # 修复：检查pump_backbone长度，避免多泵操作时出错
+                        "position": float(min(volume_left, min_transfer_volume)),
-        if len(pump_backbone) > 1:
+                        "max_velocity": transfer_flowrate
-            for pumpA, pumpB in zip(pump_backbone[:-1], pump_backbone[1:]):
-                # 相邻两泵同时切换阀门至连通位置
-                edge_AB = G.get_edge_data(pumpA, pumpB)
-                edge_BA = G.get_edge_data(pumpB, pumpA)
-                
-                if edge_AB and "port" in edge_AB and edge_BA and "port" in edge_BA:
-                    pump_action_sequence.append([
-                    {
-                        "device_id": pumpA,
-                        "action_name": "set_valve_position",
-                        "action_kwargs": {
-                            "command": edge_AB["port"][pumpA]
-                        }
-                    },
-                    {
-                        "device_id": pumpB, 
-                        "action_name": "set_valve_position",
-                        "action_kwargs": {
-                            "command": edge_BA["port"][pumpB],
-                        }
                     }
-                    ])
+                }
-                    # 相邻两泵液体转移：泵A排出液体，泵B吸入液体
+            ])
-                    pump_action_sequence.append([
+            pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
-                    {
+        for nodeA, nodeB in zip(pump_backbone[:-1], pump_backbone[1:]):
-                        "device_id": pumpA,
+            # 相邻两泵同时切换阀门至连通位置
-                        "action_name": "set_position",
+            pump_action_sequence.append([
-                        "action_kwargs": {
+                {
-                            "position": 0.0,
+                    "device_id": valve_from_node[nodeA],
-                            "max_velocity": transfer_flowrate
+                    "action_name": "set_valve_position",
-                        }
+                    "action_kwargs": {
-                    },
+                        "command": G.get_edge_data(nodeA, nodeB)["port"][nodeA]
-                    {
-                        "device_id": pumpB, 
-                        "action_name": "set_position",
-                        "action_kwargs": {
-                            "position": float(min(volume_left, min_transfer_volume)),
-                            "max_velocity": transfer_flowrate
-                        }
                     }
-                    ])
+                },
-                    pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
+                {
-                else:
+                    "device_id": valve_from_node[nodeB],
-                    print(f"Warning: No edge data found between {pumpA} and {pumpB}")
+                    "action_name": "set_valve_position",
-        
+                    "action_kwargs": {
-        if not to_vessel.startswith("pump") and pump_backbone:
+                        "command": G.get_edge_data(nodeB, nodeA)["port"][nodeB],
+                    }
+                }
+            ])
+            # 相邻两泵液体转移：泵A排出液体，泵B吸入液体
+            pump_action_sequence.append([
+                {
+                    "device_id": pumps_from_node[nodeA],
+                    "action_name": "set_position",
+                    "action_kwargs": {
+                        "position": 0.0,
+                        "max_velocity": transfer_flowrate
+                    }
+                },
+                {
+                    "device_id": pumps_from_node[nodeB],
+                    "action_name": "set_position",
+                    "action_kwargs": {
+                        "position": float(min(volume_left, min_transfer_volume)),
+                        "max_velocity": transfer_flowrate
+                    }
+                }
+            ])
+            pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
+
+        if not to_vessel.startswith("pump"):
             # 单泵依次执行阀指令、活塞指令，将最后一台泵液体缓慢加入容器B
-            edge_data = G.get_edge_data(pump_backbone[-1], to_vessel)
+            pump_action_sequence.extend([
-            if edge_data and "port" in edge_data:
+                {
-                pump_action_sequence.extend([
+                    "device_id": valve_from_node[pump_backbone[-1]],
-                    {
+                    "action_name": "set_valve_position",
-                        "device_id": pump_backbone[-1], 
+                    "action_kwargs": {
-                        "action_name": "set_valve_position",
+                        "command": G.get_edge_data(pump_backbone[-1], to_vessel)["port"][pump_backbone[-1]]
-                        "action_kwargs": {
-                            "command": edge_data["port"][pump_backbone[-1]]
-                        }
-                    },
-                    {
-                        "device_id": pump_backbone[-1], 
-                        "action_name": "set_position",
-                        "action_kwargs": {
-                            "position": 0.0,
-                            "max_velocity": flowrate
-                        }
                     }
-                ])
+                },
-                pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
+                {
-            else:
+                    "device_id": pumps_from_node[pump_backbone[-1]],
-                print(f"Warning: No edge data found between {pump_backbone[-1]} and {to_vessel}")
+                    "action_name": "set_position",
-        
+                    "action_kwargs": {
+                        "position": 0.0,
+                        "max_velocity": flowrate
+                    }
+                }
+            ])
+            pump_action_sequence.append({"action_name": "wait", "action_kwargs": {"time": 5}})
+
         volume_left -= min_transfer_volume
     return pump_action_sequence
 
 
 # Pump protocol compilation
 def generate_pump_protocol_with_rinsing(
-    G: nx.DiGraph, 
+        G: nx.DiGraph,
-    from_vessel: str, 
+        from_vessel: str,
-    to_vessel: str, 
+        to_vessel: str,
-    volume: float, 
+        volume: float,
-    amount: str = "",
+        amount: str = "",
-    time: float = 0,
+        time: float = 0,
-    viscous: bool = False,
+        viscous: bool = False,
-    rinsing_solvent: str = "air",
+        rinsing_solvent: str = "air",
-    rinsing_volume: float = 5.0,
+        rinsing_volume: float = 5.0,
-    rinsing_repeats: int = 2,
+        rinsing_repeats: int = 2,
-    solid: bool = False,
+        solid: bool = False,
-    flowrate: float = 2.5,
+        flowrate: float = 2.5,
-    transfer_flowrate: float = 0.5, 
+        transfer_flowrate: float = 0.5,
 ) -> list[dict]:
     """
     Generates a pump protocol for transferring a specified volume between vessels, including rinsing steps with a chosen solvent. This function constructs a sequence of pump actions based on the provided parameters and the shortest path in a directed graph.
-    
+
     Args:
         G (nx.DiGraph): The directed graph representing the vessels and connections. 有向图, 节点为容器和注射泵, 边为流体管道, A→B边的属性为管道接A端的阀门位置
         from_vessel (str): The name of the vessel to transfer from.
@@ -223,96 +191,64 @@ def generate_pump_protocol_with_rinsing(
         solid (bool, optional): Indicates if the transfer involves a solid (default is False).
         flowrate (float, optional): The flow rate for the transfer (default is 2.5). 最终注入容器B时的流速
         transfer_flowrate (float, optional): The flow rate for the transfer action (default is 0.5). 泵骨架中转移流速（若不指定，默认与注入流速相同）
-    
+
     Returns:
         list[dict]: A sequence of pump actions to be executed for the transfer and rinsing process. 泵操作的动作序列.
-    
+
     Raises:
         AssertionError: If the number of rinsing solvents does not match the number of rinsing repeats.
-    
+
     Examples:
         pump_protocol = generate_pump_protocol_with_rinsing(G, "vessel_A", "vessel_B", 0.1, rinsing_solvent="water")
     """
-    # 修复：使用实际存在的节点名称
+    air_vessel = "flask_air"
-    air_vessel = "flask_air"  # 这个在你的配置中存在
+    waste_vessel = f"waste_workup"
-    
+
-    # 寻找合适的废料容器，如果没有找到则使用空的容器作为替代
+    shortest_path = nx.shortest_path(G, source=from_vessel, target=to_vessel)
-    waste_vessel = None
+    pump_backbone = shortest_path[1: -1]
-    available_vessels = [node for node in G.nodes if node.startswith("flask_") and node != air_vessel]
+    nodes = G.nodes(data=True)
-    if available_vessels:
+
-        # 使用第一个可用的容器作为废料容器
+    pumps_from_node, valve_from_node = build_pump_valve_maps(G, pump_backbone)
-        waste_vessel = available_vessels[0]
+
-        print(f"Using {waste_vessel} as waste vessel")
+    min_transfer_volume = min([nodes[pumps_from_node[node]]["config"]["max_volume"] for node in pump_backbone])
-    else:
-        waste_vessel = "flask_1"  # 备用选择
-    
-    # 修复：添加路径检查
-    try:
-        shortest_path = nx.shortest_path(G, source=from_vessel, target=to_vessel)
-        pump_backbone = shortest_path[1: -1]
-    except (nx.NetworkXNoPath, nx.NodeNotFound) as e:
-        print(f"Warning: Cannot find path from {from_vessel} to {to_vessel}: {e}")
-        return []
-    
-    # 修复：正确访问节点数据
-    pump_max_volumes = []
-    for pump in pump_backbone:
-        # 直接使用 G.nodes[pump] 来访问节点数据
-        pump_data = G.nodes[pump] if pump in G.nodes else {}
-        # 尝试多种可能的键名，并提供默认值
-        max_vol = pump_data.get('max_volume') or pump_data.get('max_vol') or pump_data.get('volume')
-        if max_vol is None:
-            # 如果是设备节点，尝试从config中获取
-            config = pump_data.get('config', {})
-            max_vol = config.get('max_volume', 25.0)
-        pump_max_volumes.append(float(max_vol))
-    
-    if pump_max_volumes:
-        min_transfer_volume = float(min(pump_max_volumes))
-    else:
-        min_transfer_volume = 25.0  # 默认值
-        
     if time != 0:
         flowrate = transfer_flowrate = volume / time
-    
+
     pump_action_sequence = generate_pump_protocol(G, from_vessel, to_vessel, float(volume), flowrate, transfer_flowrate)
-    
+    if rinsing_solvent != "air" and rinsing_solvent != "":
-    # 修复：只在需要清洗且相关节点存在时才执行清洗步骤
-    if rinsing_solvent != "air" and pump_backbone:
         if "," in rinsing_solvent:
             rinsing_solvents = rinsing_solvent.split(",")
-            assert len(rinsing_solvents) == rinsing_repeats, "Number of rinsing solvents must match number of rinsing repeats."
+            assert len(
+                rinsing_solvents) == rinsing_repeats, "Number of rinsing solvents must match number of rinsing repeats."
         else:
             rinsing_solvents = [rinsing_solvent] * rinsing_repeats
-        
+
         for rinsing_solvent in rinsing_solvents:
             solvent_vessel = f"flask_{rinsing_solvent}"
-            
+            # 清洗泵
-            # 检查溶剂容器是否存在
+            pump_action_sequence.extend(
-            if solvent_vessel not in G.nodes:
+                generate_pump_protocol(G, solvent_vessel, pump_backbone[0], min_transfer_volume, flowrate,
-                print(f"Warning: Solvent vessel '{solvent_vessel}' not found in graph. Skipping rinsing step.")
+                                       transfer_flowrate) +
-                continue
+                generate_pump_protocol(G, pump_backbone[0], pump_backbone[-1], min_transfer_volume, flowrate,
-            
+                                       transfer_flowrate) +
-            # 清洗泵 - 只有当所有必需的节点都存在且pump_backbone不为空时才执行
+                generate_pump_protocol(G, pump_backbone[-1], waste_vessel, min_transfer_volume, flowrate,
-            if pump_backbone and len(pump_backbone) > 0 and waste_vessel in G.nodes:
+                                       transfer_flowrate)
+            )
+            # 如果转移的是溶液，第一种冲洗溶剂请选用溶液的溶剂，稀释泵内、转移管道内的溶液。后续冲洗溶剂不需要此操作。
+            if rinsing_solvent == rinsing_solvents[0]:
                 pump_action_sequence.extend(
-                    generate_pump_protocol(G, solvent_vessel, pump_backbone[0], min_transfer_volume, flowrate, transfer_flowrate) +
+                    generate_pump_protocol(G, solvent_vessel, from_vessel, rinsing_volume, flowrate, transfer_flowrate))
-                    generate_pump_protocol(G, pump_backbone[0], pump_backbone[-1], min_transfer_volume, flowrate, transfer_flowrate) +
+                pump_action_sequence.extend(
-                    generate_pump_protocol(G, pump_backbone[-1], waste_vessel, min_transfer_volume, flowrate, transfer_flowrate)
+                    generate_pump_protocol(G, solvent_vessel, to_vessel, rinsing_volume, flowrate, transfer_flowrate))
-                )
+            pump_action_sequence.extend(
-                
+                generate_pump_protocol(G, air_vessel, solvent_vessel, rinsing_volume, flowrate, transfer_flowrate))
-                # 如果转移的是溶液，第一种冲洗溶剂请选用溶液的溶剂，稀释泵内、转移管道内的溶液。后续冲洗溶剂不需要此操作。
+            pump_action_sequence.extend(
-                if rinsing_solvent == rinsing_solvents[0]:
+                generate_pump_protocol(G, air_vessel, waste_vessel, rinsing_volume, flowrate, transfer_flowrate))
-                    pump_action_sequence.extend(generate_pump_protocol(G, solvent_vessel, from_vessel, rinsing_volume, flowrate, transfer_flowrate))
+    if rinsing_solvent != "":
-                    pump_action_sequence.extend(generate_pump_protocol(G, solvent_vessel, to_vessel, rinsing_volume, flowrate, transfer_flowrate))
+        pump_action_sequence.extend(
-                
+            generate_pump_protocol(G, air_vessel, from_vessel, rinsing_volume, flowrate, transfer_flowrate) * 2)
-                pump_action_sequence.extend(generate_pump_protocol(G, air_vessel, solvent_vessel, rinsing_volume, flowrate, transfer_flowrate))
+        pump_action_sequence.extend(
-                pump_action_sequence.extend(generate_pump_protocol(G, air_vessel, waste_vessel, rinsing_volume, flowrate, transfer_flowrate))
+            generate_pump_protocol(G, air_vessel, to_vessel, rinsing_volume, flowrate, transfer_flowrate) * 2)
-    
+
-    # 最后的空气清洗 - 只有当节点存在时才执行
-    if air_vessel in G.nodes:
-        pump_action_sequence.extend(generate_pump_protocol(G, air_vessel, from_vessel, rinsing_volume, flowrate, transfer_flowrate) * 2)
-        pump_action_sequence.extend(generate_pump_protocol(G, air_vessel, to_vessel, rinsing_volume, flowrate, transfer_flowrate) * 2)
-    
     return pump_action_sequence
 # End Protocols

unilabos/registry/device_comms/modbus_ioboard.yaml

@@ -1,7 +1,7 @@
 io_snrd:
   description: IO Board with 16 IOs
   class:
-    module: unilabos.device_comms.SRND_16_IO:SRND_16_IO
+    module: ilabos.device_comms.SRND_16_IO:SRND_16_IO
     type: python
     hardware_interface:
       name: modbus_client

unilabos/registry/devices/pump_and_valve.yaml

@@ -71,3 +71,13 @@ solenoid_valve:
   class:
     module: unilabos.devices.pump_and_valve.solenoid_valve:SolenoidValve
     type: python
+    status_types:
+      status: String
+      valve_position: String
+    action_value_mappings:
+      set_valve_position:
+        type: StrSingleInput
+        goal:
+          string: position
+        feedback: {}
+        result: {}

unilabos/ros/nodes/base_device_node.py

@@ -601,10 +601,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
             goal = goal_handle.request
 
             # 从目标消息中提取参数, 并调用对应的方法
-            if "sequence" in self._action_value_mappings:
+            if "sequence" in action_value_mapping:
                 # 如果一个指令对应函数的连续调用，如启动和等待结果，默认参数应该属于第一个函数调用
                 def ACTION(**kwargs):
-                    for i, action in enumerate(self._action_value_mappings["sequence"]):
+                    for i, action in enumerate(action_value_mapping["sequence"]):
                         if i == 0:
                             self.lab_logger().info(f"执行序列动作第一步: {action}")
                             self.get_real_function(self.driver_instance, action)[0](**kwargs)
@@ -612,9 +612,7 @@ class BaseROS2DeviceNode(Node, Generic[T]):
                             self.lab_logger().info(f"执行序列动作后续步骤: {action}")
                             self.get_real_function(self.driver_instance, action)[0]()
 
-                action_paramtypes = get_type_hints(
+                action_paramtypes = self.get_real_function(self.driver_instance, action_value_mapping["sequence"][0])[1]
-                    self.get_real_function(self.driver_instance, self._action_value_mappings["sequence"][0])
-                )[1]
             else:
                 ACTION, action_paramtypes = self.get_real_function(self.driver_instance, action_name)
 

unilabos/ros/nodes/presets/protocol_node.py

@@ -256,12 +256,12 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
             return write_func(*args, **kwargs)
 
         if read_method:
-            bound_read = MethodType(_read, device.driver_instance)
+            # bound_read = MethodType(_read, device.driver_instance)
-            setattr(device.driver_instance, read_method, bound_read)
+            setattr(device.driver_instance, read_method, _read)
 
         if write_method:
-            bound_write = MethodType(_write, device.driver_instance)
+            # bound_write = MethodType(_write, device.driver_instance)
-            setattr(device.driver_instance, write_method, bound_write)
+            setattr(device.driver_instance, write_method, _write)
 
 
     async def _update_resources(self, goal, protocol_kwargs):