Update workstation code for YB4 0107

合并dev分支

.conda/recipe.yaml

@@ -1,6 +1,6 @@
 package:
   name: unilabos
-  version: 0.10.11
+  version: 0.10.12
 
 source:
   path: ../unilabos

README.md

@@ -39,7 +39,9 @@ Uni-Lab-OS recommends using `mamba` for environment management. Choose the appro
 
 ```bash
 # Create new environment
-mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
+mamba create -n unilab python=3.11.11
+mamba activate unilab
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
 ## Install Dev Uni-Lab-OS

README_zh.md

@@ -41,7 +41,9 @@ Uni-Lab-OS 建议使用 `mamba` 管理环境。根据您的操作系统选择适
 
 ```bash
 # 创建新环境
-mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
+mamba create -n unilab python=3.11.11
+mamba activate unilab
+mamba install -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 ```
 
 2. 安装开发版 Uni-Lab-OS:

bioyond_yihua_YB.json

@@ -1,31 +1,32 @@
 {
   "nodes": [
     {
-      "id": "BatteryStation",
-      "name": "扣电工作站",
+      "id": "bioyond_cell_workstation",
+      "name": "配液分液工站",
       "children": [
-          "coin_cell_deck"
       ],
       "parent": null,
       "type": "device",
-      "class": "bettery_station_registry",
-      "position": {
-          "x": 600,
-          "y": 400,
-          "z": 0
+      "class": "bioyond_cell",
+      "config": {
+          "protocol_type": [],
+          "station_resource": {}
       },
+      "data": {}
+  },
+    {
+      "id": "BatteryStation",
+      "name": "扣电组装工作站",
+      "children": [],
+      "parent": null,
+      "type": "device",
+      "class": "bettery_station_registry",
       "config": {
           "debug_mode": false,
-          "_comment": "protocol_type接外部工站固定写法字段，一般为空，deck写法也固定",
+
           "protocol_type": [],
-          "deck": {
-              "data": {
-                  "_resource_child_name": "coin_cell_deck",
-                  "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.button_battery_station:CoincellDeck"
-              }
-          },
-          
-          "address": "192.168.1.20",
+          "deck": "unilabos.devices.workstation.coin_cell_assembly.button_battery_station:CoincellDeck",
+          "address": "172.21.32.20",
           "port": 502
       },
       "data": {}
@@ -98,7 +99,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine_four",
+        "type": "MagazineHolder_4",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -139,7 +140,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -234,7 +235,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -329,7 +330,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -424,7 +425,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -522,7 +523,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine_four",
+        "type": "MagazineHolder_4",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -563,7 +564,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -658,7 +659,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -753,7 +754,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -848,7 +849,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -948,7 +949,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -991,7 +992,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1086,7 +1087,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1181,7 +1182,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1276,7 +1277,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1371,7 +1372,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1466,7 +1467,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1566,7 +1567,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -1609,7 +1610,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1704,7 +1705,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1799,7 +1800,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1894,7 +1895,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1989,7 +1990,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2084,7 +2085,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2184,7 +2185,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2227,7 +2228,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2322,7 +2323,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2417,7 +2418,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2512,7 +2513,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2607,7 +2608,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2702,7 +2703,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2802,7 +2803,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2845,7 +2846,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2940,7 +2941,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3035,7 +3036,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3130,7 +3131,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3225,7 +3226,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3320,7 +3321,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3420,7 +3421,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -3463,7 +3464,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3558,7 +3559,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3653,7 +3654,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3748,7 +3749,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3843,7 +3844,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3938,7 +3939,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4038,7 +4039,7 @@
         "z": 0
       },
       "config": {
-        "type": "ClipMagazine",
+        "type": "MagazineHolder_6",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -4081,7 +4082,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4176,7 +4177,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4271,7 +4272,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4366,7 +4367,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4461,7 +4462,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4556,7 +4557,7 @@
         "z": 10
       },
       "config": {
-        "type": "ClipMagazineHole",
+        "type": "Magazine",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,

docs/advanced_usage/configuration.md

@@ -67,14 +67,6 @@ class WSConfig:
     max_reconnect_attempts = 999  # 最大重连次数
     ping_interval = 30  # ping间隔（秒）
 
-# OSS上传配置
-class OSSUploadConfig:
-    api_host = ""  # API主机地址
-    authorization = ""  # 授权信息
-    init_endpoint = ""  # 初始化端点
-    complete_endpoint = ""  # 完成端点
-    max_retries = 3  # 最大重试次数
-
 # HTTP配置
 class HTTPConfig:
     remote_addr = "https://uni-lab.bohrium.com/api/v1"  # 远程服务器地址
@@ -294,19 +286,7 @@ HTTP 客户端配置用于与云端服务通信：
 - UAT 环境：`https://uni-lab.uat.bohrium.com/api/v1`
 - 本地环境：`http://127.0.0.1:48197/api/v1`
 
-### 4. OSSUploadConfig - OSS 上传配置
-
-对象存储服务配置，用于文件上传功能：
-
-| 参数                | 类型 | 默认值 | 说明                 |
-| ------------------- | ---- | ------ | -------------------- |
-| `api_host`          | str  | `""`   | OSS API 主机地址     |
-| `authorization`     | str  | `""`   | 授权认证信息         |
-| `init_endpoint`     | str  | `""`   | 上传初始化端点       |
-| `complete_endpoint` | str  | `""`   | 上传完成端点         |
-| `max_retries`       | int  | `3`    | 上传失败最大重试次数 |
-
-### 5. ROSConfig - ROS 配置
+### 4. ROSConfig - ROS 配置
 
 配置 ROS 消息转换器需要加载的模块：
 

docs/developer_guide/add_registry.md

@@ -4,7 +4,8 @@
 
 ## 概述
 
-注册表（Registry）是Uni-Lab的设备配置系统，采用YAML格式定义设备的：
+注册表（Registry）是 Uni-Lab 的设备配置系统，采用 YAML 格式定义设备的：
+
 - 可用动作（Actions）
 - 状态类型（Status Types）
 - 初始化参数（Init Parameters）
@@ -32,19 +33,19 @@
 
 ### 核心字段说明
 
-| 字段名            | 类型   | 需要手写 | 说明                                |
-| ----------------- | ------ | -------- | ----------------------------------- |
-| 设备标识符        | string | 是       | 设备的唯一名字，如 `mock_chiller`   |
-| class             | object | 部分     | 设备的核心信息，必须配置            |
-| description       | string | 否       | 设备描述，系统默认给空字符串        |
-| handles           | array  | 否       | 连接关系，默认为空                  |
-| icon              | string | 否       | 图标路径，默认为空                  |
-| init_param_schema | object | 否       | 初始化参数，系统自动分析生成        |
-| version           | string | 否       | 版本号，默认 "1.0.0"                |
-| category          | array  | 否       | 设备分类，默认使用文件名            |
-| config_info       | array  | 否       | 嵌套配置，默认为空                  |
-| file_path         | string | 否       | 文件路径，系统自动设置              |
-| registry_type     | string | 否       | 注册表类型，自动设为 "device"       |
+| 字段名            | 类型   | 需要手写 | 说明                              |
+| ----------------- | ------ | -------- | --------------------------------- |
+| 设备标识符        | string | 是       | 设备的唯一名字，如 `mock_chiller` |
+| class             | object | 部分     | 设备的核心信息，必须配置          |
+| description       | string | 否       | 设备描述，系统默认给空字符串      |
+| handles           | array  | 否       | 连接关系，默认为空                |
+| icon              | string | 否       | 图标路径，默认为空                |
+| init_param_schema | object | 否       | 初始化参数，系统自动分析生成      |
+| version           | string | 否       | 版本号，默认 "1.0.0"              |
+| category          | array  | 否       | 设备分类，默认使用文件名          |
+| config_info       | array  | 否       | 嵌套配置，默认为空                |
+| file_path         | string | 否       | 文件路径，系统自动设置            |
+| registry_type     | string | 否       | 注册表类型，自动设为 "device"     |
 
 ### class 字段详解
 
@@ -71,11 +72,11 @@ my_device:
       # 动作配置（详见后文）
       action_name:
         type: UniLabJsonCommand
-        goal: {...}
-        result: {...}
+        goal: { ... }
+        result: { ... }
 
-  description: "设备描述"
-  version: "1.0.0"
+  description: '设备描述'
+  version: '1.0.0'
   category:
     - device_category
   handles: []
@@ -101,21 +102,22 @@ my_device:
 
 ## 创建注册表的方式
 
-### 方式1: 使用注册表编辑器（推荐）
+### 方式 1: 使用注册表编辑器（推荐）
 
 适合大多数场景，快速高效。
 
 **步骤**：
-1. 启动Uni-Lab
-2. 访问Web界面的"注册表编辑器"
-3. 上传您的Python设备驱动文件
+
+1. 启动 Uni-Lab
+2. 访问 Web 界面的"注册表编辑器"
+3. 上传您的 Python 设备驱动文件
 4. 点击"分析文件"
 5. 填写描述和图标
 6. 点击"生成注册表"
-7. 复制生成的YAML内容
+7. 复制生成的 YAML 内容
 8. 保存到 `unilabos/registry/devices/your_device.yaml`
 
-### 方式2: 使用--complete_registry参数（开发调试）
+### 方式 2: 使用--complete_registry 参数（开发调试）
 
 适合开发阶段，自动补全配置。
 
@@ -125,7 +127,8 @@ unilab -g dev.json --complete_registry --registry_path ./my_registry
 ```
 
 系统会：
-1. 扫描Python类
+
+1. 扫描 Python 类
 2. 分析方法签名和类型
 3. 自动生成缺失的字段
 4. 保存到注册表文件
@@ -137,7 +140,7 @@ unilab -g dev.json --complete_registry --registry_path ./my_registry
 启动系统时用 complete_registry=True 参数，让系统自动补全
 ```
 
-### 方式3: 手动编写（高级）
+### 方式 3: 手动编写（高级）
 
 适合需要精细控制或特殊需求的场景。
 
@@ -186,6 +189,7 @@ my_device:
 | ROS 动作类型           | 标准 ROS 动作        | goal_default 和 schema |
 
 **常用的 ROS 动作类型**：
+
 - `SendCmd`：发送简单命令
 - `NavigateThroughPoses`：导航动作
 - `SingleJointPosition`：单关节位置控制
@@ -251,11 +255,11 @@ heat_chill_start:
 
 ## 特殊类型的自动识别
 
-### ResourceSlot和DeviceSlot识别
+### ResourceSlot 和 DeviceSlot 识别
 
 当您在驱动代码中使用这些特殊类型时，系统会自动识别并生成相应的前端选择器。
 
-**Python驱动代码示例**：
+**Python 驱动代码示例**：
 
 ```python
 from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
@@ -286,24 +290,24 @@ my_device:
           device: device
           devices: devices
         placeholder_keys:
-          resource: unilabos_resources      # 自动添加！
-          resources: unilabos_resources     # 自动添加！
-          device: unilabos_devices          # 自动添加！
-          devices: unilabos_devices         # 自动添加！
+          resource: unilabos_resources # 自动添加！
+          resources: unilabos_resources # 自动添加！
+          device: unilabos_devices # 自动添加！
+          devices: unilabos_devices # 自动添加！
         result:
           success: success
 ```
 
 ### 识别规则
 
-| Python类型 | placeholder_keys值 | 前端效果 |
-|-----------|-------------------|---------|
-| `ResourceSlot` | `unilabos_resources` | 单选资源下拉框 |
+| Python 类型          | placeholder_keys 值  | 前端效果       |
+| -------------------- | -------------------- | -------------- |
+| `ResourceSlot`       | `unilabos_resources` | 单选资源下拉框 |
 | `List[ResourceSlot]` | `unilabos_resources` | 多选资源下拉框 |
-| `DeviceSlot` | `unilabos_devices` | 单选设备下拉框 |
-| `List[DeviceSlot]` | `unilabos_devices` | 多选设备下拉框 |
+| `DeviceSlot`         | `unilabos_devices`   | 单选设备下拉框 |
+| `List[DeviceSlot]`   | `unilabos_devices`   | 多选设备下拉框 |
 
-### 前端UI效果
+### 前端 UI 效果
 
 #### 单选资源
 
@@ -313,6 +317,7 @@ placeholder_keys:
 ```
 
 **前端渲染**:
+
 ```
 Source: [下拉选择框 ▼]
         ├── plate_1 (96孔板)
@@ -329,6 +334,7 @@ placeholder_keys:
 ```
 
 **前端渲染**:
+
 ```
 Targets: [多选下拉框 ▼]
          ☑ plate_1 (96孔板)
@@ -345,6 +351,7 @@ placeholder_keys:
 ```
 
 **前端渲染**:
+
 ```
 Pump: [下拉选择框 ▼]
       ├── pump_1 (注射泵A)
@@ -360,6 +367,7 @@ placeholder_keys:
 ```
 
 **前端渲染**:
+
 ```
 Sync Devices: [多选下拉框 ▼]
               ☑ heater_1 (加热器A)
@@ -367,11 +375,11 @@ Sync Devices: [多选下拉框 ▼]
               ☐ pump_1 (注射泵)
 ```
 
-### 手动配置placeholder_keys
+### 手动配置 placeholder_keys
 
-如果需要手动添加或覆盖自动生成的placeholder_keys：
+如果需要手动添加或覆盖自动生成的 placeholder_keys：
 
-#### 场景1: 非标准参数名
+#### 场景 1: 非标准参数名
 
 ```yaml
 action_value_mappings:
@@ -384,7 +392,7 @@ action_value_mappings:
       my_device_param: unilabos_devices
 ```
 
-#### 场景2: 混合类型
+#### 场景 2: 混合类型
 
 ```python
 def mixed_params(
@@ -398,32 +406,33 @@ def mixed_params(
 
 ```yaml
 placeholder_keys:
-  resource: unilabos_resources    # 资源选择
-  device: unilabos_devices        # 设备选择
+  resource: unilabos_resources # 资源选择
+  device: unilabos_devices # 设备选择
   # normal_param不需要placeholder_keys
 ```
 
-#### 场景3: 自定义选择器
+#### 场景 3: 自定义选择器
 
 ```yaml
 placeholder_keys:
-  special_param: custom_selector   # 使用自定义选择器
+  special_param: custom_selector # 使用自定义选择器
 ```
 
 ## 系统自动生成的字段
 
 ### status_types
 
-系统会扫描你的 Python 类，从状态方法（property或get_方法）自动生成这部分：
+系统会扫描你的 Python 类，从状态方法（property 或 get\_方法）自动生成这部分：
 
 ```yaml
 status_types:
   current_temperature: float # 从 get_current_temperature() 或 @property current_temperature
-  is_heating: bool           # 从 get_is_heating() 或 @property is_heating
-  status: str               # 从 get_status() 或 @property status
+  is_heating: bool # 从 get_is_heating() 或 @property is_heating
+  status: str # 从 get_status() 或 @property status
 ```
 
 **注意事项**：
+
 - 系统会查找所有 `get_` 开头的方法和 `@property` 装饰的属性
 - 类型会自动转成相应的类型（如 `str`、`float`、`bool`）
 - 如果类型是 `Any`、`None` 或未知的，默认使用 `String`
@@ -459,20 +468,21 @@ init_param_schema:
 ```
 
 **生成规则**：
+
 - `config` 部分：分析 `__init__` 方法的参数、类型和默认值
 - `data` 部分：根据 `status_types` 生成前端显示用的类型定义
 
 ### 其他自动填充的字段
 
 ```yaml
-version: '1.0.0'          # 默认版本
-category: ['文件名']       # 使用 yaml 文件名作为类别
-description: ''           # 默认为空
-icon: ''                  # 默认为空
-handles: []               # 默认空数组
-config_info: []           # 默认空数组
+version: '1.0.0' # 默认版本
+category: ['文件名'] # 使用 yaml 文件名作为类别
+description: '' # 默认为空
+icon: '' # 默认为空
+handles: [] # 默认空数组
+config_info: [] # 默认空数组
 file_path: '/path/to/file' # 系统自动填写
-registry_type: 'device'   # 自动设为设备类型
+registry_type: 'device' # 自动设为设备类型
 ```
 
 ### handles 字段
@@ -510,7 +520,7 @@ config_info: # 嵌套配置，用于包含子设备
 
 ## 完整示例
 
-### Python驱动代码
+### Python 驱动代码
 
 ```python
 # unilabos/devices/my_lab/liquid_handler.py
@@ -520,22 +530,22 @@ from typing import List, Dict, Any, Optional
 
 class AdvancedLiquidHandler:
     """高级液体处理工作站"""
-    
+
     def __init__(self, config: Dict[str, Any]):
         self.simulation = config.get('simulation', False)
         self._status = "idle"
         self._temperature = 25.0
-    
+
     @property
     def status(self) -> str:
         """设备状态"""
         return self._status
-    
+
     @property
     def temperature(self) -> float:
         """当前温度"""
         return self._temperature
-    
+
     def transfer(
         self,
         source: ResourceSlot,
@@ -545,7 +555,7 @@ class AdvancedLiquidHandler:
     ) -> Dict[str, Any]:
         """转移液体"""
         return {"success": True}
-    
+
     def multi_transfer(
         self,
         source: ResourceSlot,
@@ -554,7 +564,7 @@ class AdvancedLiquidHandler:
     ) -> Dict[str, Any]:
         """多目标转移"""
         return {"success": True}
-    
+
     def coordinate_with_heater(
         self,
         plate: ResourceSlot,
@@ -574,12 +584,12 @@ advanced_liquid_handler:
   class:
     module: unilabos.devices.my_lab.liquid_handler:AdvancedLiquidHandler
     type: python
-    
+
     # 自动提取的状态类型
     status_types:
       status: str
       temperature: float
-    
+
     # 自动生成的初始化参数
     init_param_schema:
       config:
@@ -597,7 +607,7 @@ advanced_liquid_handler:
         required:
           - status
         type: object
-    
+
     # 动作映射
     action_value_mappings:
       transfer:
@@ -613,28 +623,28 @@ advanced_liquid_handler:
           volume: 0.0
           tip: null
         placeholder_keys:
-          source: unilabos_resources      # 自动添加
-          target: unilabos_resources      # 自动添加
-          tip: unilabos_resources         # 自动添加
+          source: unilabos_resources # 自动添加
+          target: unilabos_resources # 自动添加
+          tip: unilabos_resources # 自动添加
         result:
           success: success
         schema:
-          description: "转移液体"
+          description: '转移液体'
           properties:
             goal:
               properties:
                 source:
                   type: object
-                  description: "源容器"
+                  description: '源容器'
                 target:
                   type: object
-                  description: "目标容器"
+                  description: '目标容器'
                 volume:
                   type: number
-                  description: "体积(μL)"
+                  description: '体积(μL)'
                 tip:
                   type: object
-                  description: "枪头(可选)"
+                  description: '枪头(可选)'
               required:
                 - source
                 - target
@@ -643,7 +653,7 @@ advanced_liquid_handler:
           required:
             - goal
           type: object
-      
+
       multi_transfer:
         type: UniLabJsonCommand
         goal:
@@ -651,11 +661,11 @@ advanced_liquid_handler:
           targets: targets
           volumes: volumes
         placeholder_keys:
-          source: unilabos_resources      # 单选
-          targets: unilabos_resources     # 多选
+          source: unilabos_resources # 单选
+          targets: unilabos_resources # 多选
         result:
           success: success
-      
+
       coordinate_with_heater:
         type: UniLabJsonCommand
         goal:
@@ -663,17 +673,17 @@ advanced_liquid_handler:
           heater: heater
           temperature: temperature
         placeholder_keys:
-          plate: unilabos_resources       # 资源选择
-          heater: unilabos_devices        # 设备选择
+          plate: unilabos_resources # 资源选择
+          heater: unilabos_devices # 设备选择
         result:
           success: success
-  
-  description: "高级液体处理工作站，支持多目标转移和设备协同"
-  version: "1.0.0"
+
+  description: '高级液体处理工作站，支持多目标转移和设备协同'
+  version: '1.0.0'
   category:
     - liquid_handling
   handles: []
-  icon: ""
+  icon: ''
 ```
 
 ### 另一个完整示例：温度控制器
@@ -892,17 +902,18 @@ unilab -g dev.json --complete_registry
 cat unilabos/registry/devices/my_device.yaml
 ```
 
-### 2. 验证placeholder_keys
+### 2. 验证 placeholder_keys
 
 确认：
-- ResourceSlot参数有 `unilabos_resources`
-- DeviceSlot参数有 `unilabos_devices`
-- List类型被正确识别
+
+- ResourceSlot 参数有 `unilabos_resources`
+- DeviceSlot 参数有 `unilabos_devices`
+- List 类型被正确识别
 
 ### 3. 测试前端效果
 
-1. 启动Uni-Lab
-2. 访问Web界面
+1. 启动 Uni-Lab
+2. 访问 Web 界面
 3. 选择设备
 4. 调用动作
 5. 检查是否显示正确的选择器
@@ -916,18 +927,21 @@ python -c "from unilabos.devices.my_module.my_device import MyDevice"
 
 ## 常见问题
 
-### Q1: placeholder_keys没有自动生成
+### Q1: placeholder_keys 没有自动生成
 
 **检查**:
+
 1. 是否使用了`--complete_registry`参数？
 2. 类型注解是否正确？
+
    ```python
    # ✓ 正确
    def method(self, resource: ResourceSlot):
-   
+
    # ✗ 错误（缺少类型注解）
    def method(self, resource):
    ```
+
 3. 是否正确导入？
    ```python
    from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot
@@ -935,9 +949,10 @@ python -c "from unilabos.devices.my_module.my_device import MyDevice"
 
 ### Q2: 前端显示普通输入框而不是选择器
 
-**原因**: placeholder_keys未正确配置
+**原因**: placeholder_keys 未正确配置
 
 **解决**:
+
 ```yaml
 # 检查YAML中是否有
 placeholder_keys:
@@ -947,6 +962,7 @@ placeholder_keys:
 ### Q3: 多选不工作
 
 **检查类型注解**:
+
 ```python
 # ✓ 正确 - 会生成多选
 def method(self, resources: List[ResourceSlot]):
@@ -960,13 +976,15 @@ def method(self, resources: ResourceSlot):
 **说明**: 运行时会自动转换
 
 前端传递：
+
 ```json
 {
-  "resource": "plate_1"  // 字符串ID
+  "resource": "plate_1" // 字符串ID
 }
 ```
 
 运行时收到：
+
 ```python
 resource.id        # "plate_1"
 resource.name      # "96孔板"
@@ -977,6 +995,7 @@ resource.type      # "resource"
 ### Q5: 设备加载不了
 
 **检查**:
+
 1. 确认 `class.module` 路径是否正确
 2. 确认 Python 驱动类能否正常导入
 3. 使用 yaml 验证器检查文件格式
@@ -985,6 +1004,7 @@ resource.type      # "resource"
 ### Q6: 自动生成失败
 
 **检查**:
+
 1. 确认类继承了正确的基类
 2. 确保状态方法的返回类型注解清晰
 3. 检查类能否被动态导入
@@ -993,6 +1013,7 @@ resource.type      # "resource"
 ### Q7: 前端显示问题
 
 **解决步骤**:
+
 1. 删除旧的 yaml 文件，用编辑器重新生成
 2. 清除浏览器缓存，重新加载页面
 3. 确认必需字段（如 `schema`）都存在
@@ -1001,6 +1022,7 @@ resource.type      # "resource"
 ### Q8: 动作执行出错
 
 **检查**:
+
 1. 确认动作方法名符合规范（如 `execute_<action_name>`）
 2. 检查 `goal` 字段的参数映射是否正确
 3. 确认方法返回值格式符合 `result` 映射
@@ -1041,7 +1063,7 @@ def transfer(self, r1: ResourceSlot, r2: ResourceSlot):
     pass
 ```
 
-3. **使用Optional表示可选参数**
+3. **使用 Optional 表示可选参数**
 
 ```python
 from typing import Optional
@@ -1063,11 +1085,11 @@ def method(
     targets: List[ResourceSlot]  # 目标容器列表
 ) -> Dict[str, Any]:
     """方法说明
-    
+
     Args:
         source: 源容器，必须包含足够的液体
         targets: 目标容器列表，每个容器应该为空
-    
+
     Returns:
         包含操作结果的字典
     """
@@ -1075,6 +1097,7 @@ def method(
 ```
 
 5. **方法命名规范**
+
    - 状态方法使用 `@property` 装饰器或 `get_` 前缀
    - 动作方法使用动词开头
    - 保持命名清晰、一致
@@ -1111,8 +1134,6 @@ def method(
 
 - {doc}`add_device` - 设备驱动编写指南
 - {doc}`04_add_device_testing` - 设备测试指南
-- Python [typing模块](https://docs.python.org/3/library/typing.html)
-- [YAML语法](https://yaml.org/)
+- Python [typing 模块](https://docs.python.org/3/library/typing.html)
+- [YAML 语法](https://yaml.org/)
 - [JSON Schema](https://json-schema.org/)
-
-

docs/developer_guide/examples/battery_plc_workstation.md

@@ -1,4 +1,4 @@
-# 实例：电池装配工站接入（PLC控制）
+# 实例：电池装配工站接入（PLC 控制）
 
 > **文档类型**：实际应用案例  
 > **适用场景**：使用 PLC 控制的电池装配工站接入  
@@ -50,8 +50,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         self.client = tcp.register_node_list(self.nodes)
 ```
 
-
-
 ## 2. 编写驱动与寄存器读写
 
 ### 2.1 寄存器示例
@@ -95,9 +93,9 @@ def start_and_read_metrics(self):
 
 完成工站类与驱动后，需要生成（或更新）工站注册表供系统识别。
 
-
 ### 3.1 新增工站设备（或资源）首次生成注册表
-首先通过以下命令启动unilab。进入unilab系统状态检查页面
+
+首先通过以下命令启动 unilab。进入 unilab 系统状态检查页面
 
 ```bash
 python unilabos\app\main.py -g celljson.json --ak <user的AK> --sk <user的SK>
@@ -112,35 +110,32 @@ python unilabos\app\main.py -g celljson.json --ak <user的AK> --sk <user的SK>
 ![注册表生成流程](image_battery_plc/unilab_registry_process.png)
 
 步骤说明：
+
 1. 选择新增的工站`coin_cell_assembly.py`文件
 2. 点击分析按钮，分析`coin_cell_assembly.py`文件
 3. 选择`coin_cell_assembly.py`文件中继承`WorkstationBase`类
-4. 填写新增的工站.py文件与`unilabos`目录的距离。例如，新增的工站文件`coin_cell_assembly.py`路径为`unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly.py`，则此处填写`unilabos.devices.workstation.coin_cell_assembly`。
+4. 填写新增的工站.py 文件与`unilabos`目录的距离。例如，新增的工站文件`coin_cell_assembly.py`路径为`unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly.py`，则此处填写`unilabos.devices.workstation.coin_cell_assembly`。
 5. 此处填写新定义工站的类的名字（名称可以自拟）
 6. 填写新的工站注册表备注信息
 7. 生成注册表
 
-以上操作步骤完成，则会生成的新的注册表YAML文件，如下图：
+以上操作步骤完成，则会生成的新的注册表 YAML 文件，如下图：
 
 ![生成的YAML文件](image_battery_plc/unilab_new_yaml.png)
 
-
-
-
-
-
 ### 3.2 添加新生成注册表
-在`unilabos\registry\devices`目录下新建一个yaml文件，此处新建文件命名为`coincellassemblyworkstation_device.yaml`，将上面生成的新的注册表信息粘贴到`coincellassemblyworkstation_device.yaml`文件中。   
+
+在`unilabos\registry\devices`目录下新建一个 yaml 文件，此处新建文件命名为`coincellassemblyworkstation_device.yaml`，将上面生成的新的注册表信息粘贴到`coincellassemblyworkstation_device.yaml`文件中。
 
 在终端输入以下命令进行注册表补全操作。
+
 ```bash
 python unilabos\app\register.py --complete_registry
 ```
 
-
 ### 3.3 启动并上传注册表
 
-新增设备之后，启动unilab需要增加`--upload_registry`参数，来上传注册表信息。
+新增设备之后，启动 unilab 需要增加`--upload_registry`参数，来上传注册表信息。
 
 ```bash
 python unilabos\app\main.py -g celljson.json --ak <user的AK> --sk <user的SK> --upload_registry
@@ -159,6 +154,7 @@ module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinC
 ### 4.2 首次接入流程
 
 首次新增设备（或资源）需要完整流程：
+
 1. ✅ 在网页端生成注册表信息
 2. ✅ 使用 `--complete_registry` 补全注册表
 3. ✅ 使用 `--upload_registry` 上传注册表信息
@@ -166,11 +162,12 @@ module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinC
 ### 4.3 驱动更新流程
 
 如果不是新增设备，仅修改了工站驱动的 `.py` 文件：
+
 1. ✅ 运行 `--complete_registry` 补全注册表
 2. ✅ 运行 `--upload_registry` 上传注册表
 3. ❌ 不需要在网页端重新生成注册表
 
-### 4.4 PLC通信注意事项
+### 4.4 PLC 通信注意事项
 
 - **握手机制**：若需参数下发，建议在 PLC 端设置标志寄存器并完成握手复位，避免粘连与竞争
 - **字节序**：FLOAT32 等多字节数据类型需要正确指定字节序（如 `WorderOrder.LITTLE`）
@@ -203,5 +200,3 @@ module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinC
 5. ✅ 新增设备与更新驱动的区别
 
 这个案例展示了完整的 PLC 设备接入流程，可以作为其他类似设备接入的参考模板。
-
-

docs/developer_guide/examples/workstation_architecture.md

@@ -16,8 +16,8 @@
 
 这类工站由开发者自研，组合所有子设备和实验耗材、希望让他们在工作站这一级协调配合；
 
-1. 工作站包含大量已经注册的子设备，可能各自通信组态很不相同；部分设备可能会拥有同一个通信设备作为出口，如2个泵共用1个串口、所有设备共同接入PLC等。
-2. 任务系统是统一实现的 protocols，protocols 中会将高层指令处理成各子设备配合的工作流 json并管理执行、同时更改物料信息
+1. 工作站包含大量已经注册的子设备，可能各自通信组态很不相同；部分设备可能会拥有同一个通信设备作为出口，如 2 个泵共用 1 个串口、所有设备共同接入 PLC 等。
+2. 任务系统是统一实现的 protocols，protocols 中会将高层指令处理成各子设备配合的工作流 json 并管理执行、同时更改物料信息
 3. 物料系统较为简单直接，如常量有机化学仅为工作站内固定的瓶子，初始化时就已固定；随后在任务执行过程中，记录试剂量更改信息
 
 ### 0.2 移液工作站：物料系统和工作流模板管理
@@ -35,7 +35,7 @@
 由厂家开发，具备完善的物料系统、任务系统甚至调度系统；由 PLC 或 OpenAPI TCP 协议统一通信
 
 1. 在监控状态时，希望展现子设备的状态；但子设备仅为逻辑概念，通信由工作站上位机接口提供；部分情况下，子设备状态是被记录在文件中的，需要读取
-2. 工作站有自己的工作流系统甚至调度系统；可以通过脚本/PLC连续读写来配置工作站可用的工作流；
+2. 工作站有自己的工作流系统甚至调度系统；可以通过脚本/PLC 连续读写来配置工作站可用的工作流；
 3. 部分拥有完善的物料入库、出库、过程记录，需要与 Uni-Lab-OS 物料系统对接
 
 ## 1. 整体架构图
@@ -49,7 +49,7 @@ graph TB
         RPN[ROS2WorkstationNode<br/>Protocol执行引擎]
         WB -.post_init关联.-> RPN
     end
-    
+
     subgraph "物料管理系统"
         DECK[Deck<br/>PLR本地物料系统]
         RS[ResourceSynchronizer<br/>外部物料同步器]
@@ -57,7 +57,7 @@ graph TB
         WB --> RS
         RS --> DECK
     end
-    
+
     subgraph "通信与子设备管理"
         HW[hardware_interface<br/>硬件通信接口]
         SUBDEV[子设备集合<br/>pumps/grippers/sensors]
@@ -65,7 +65,7 @@ graph TB
         RPN --> SUBDEV
         HW -.代理模式.-> RPN
     end
-    
+
     subgraph "工作流任务系统"
         PROTO[Protocol定义<br/>LiquidHandling/PlateHandling]
         WORKFLOW[Workflow执行器<br/>步骤管理与编排]
@@ -85,32 +85,32 @@ graph LR
         HW2[通信接口<br/>hardware_interface]
         HTTP[HTTP服务<br/>WorkstationHTTPService]
     end
-    
+
     subgraph "外部物料系统"
         BIOYOND[Bioyond物料管理]
         LIMS[LIMS系统]
         WAREHOUSE[第三方仓储]
     end
-    
+
     subgraph "外部硬件系统"
         PLC[PLC设备]
         SERIAL[串口设备]
         ROBOT[机械臂/机器人]
     end
-    
+
     subgraph "云端系统"
         CLOUD[UniLab云端<br/>资源管理]
         MONITOR[监控与调度]
     end
-    
+
     BIOYOND <-->|RPC双向同步| DECK2
     LIMS -->|HTTP报送| HTTP
     WAREHOUSE <-->|API对接| DECK2
-    
+
     PLC <-->|Modbus TCP| HW2
     SERIAL <-->|串口通信| HW2
     ROBOT <-->|SDK/API| HW2
-    
+
     WS -->|ROS消息| CLOUD
     CLOUD -->|任务下发| WS
     MONITOR -->|状态查询| WS
@@ -123,40 +123,40 @@ graph TB
     subgraph "工作站基类"
         BASE[WorkstationBase<br/>抽象基类]
     end
-    
+
     subgraph "Bioyond集成工作站"
         BW[BioyondWorkstation]
         BW_DECK[Deck + Warehouses]
         BW_SYNC[BioyondResourceSynchronizer]
         BW_HW[BioyondV1RPC]
         BW_HTTP[HTTP报送服务]
-        
+
         BW --> BW_DECK
         BW --> BW_SYNC
         BW --> BW_HW
         BW --> BW_HTTP
     end
-    
+
     subgraph "纯协议节点"
         PN[ProtocolNode]
         PN_SUB[子设备集合]
         PN_PROTO[Protocol工作流]
-        
+
         PN --> PN_SUB
         PN --> PN_PROTO
     end
-    
+
     subgraph "PLC控制工作站"
         PW[PLCWorkstation]
         PW_DECK[Deck物料系统]
         PW_PLC[Modbus PLC客户端]
         PW_WF[工作流定义]
-        
+
         PW --> PW_DECK
         PW --> PW_PLC
         PW --> PW_WF
     end
-    
+
     BASE -.继承.-> BW
     BASE -.继承.-> PN
     BASE -.继承.-> PW
@@ -175,25 +175,25 @@ classDiagram
         +hardware_interface: Union[Any, str]
         +current_workflow_status: WorkflowStatus
         +supported_workflows: Dict[str, WorkflowInfo]
-    
+
         +post_init(ros_node)*
         +set_hardware_interface(interface)
         +call_device_method(method, *args, **kwargs)
         +get_device_status()
         +is_device_available()
-    
+
         +get_deck()
         +get_all_resources()
         +find_resource_by_name(name)
         +find_resources_by_type(type)
         +sync_with_external_system()
-    
+
         +execute_workflow(name, params)
         +stop_workflow(emergency)
         +workflow_status
         +is_busy
     }
-  
+
     class ROS2WorkstationNode {
         +device_id: str
         +children: Dict[str, Any]
@@ -202,7 +202,7 @@ classDiagram
         +_action_clients: Dict
         +_action_servers: Dict
         +resource_tracker: DeviceNodeResourceTracker
-    
+
         +initialize_device(device_id, config)
         +create_ros_action_server(action_name, mapping)
         +execute_single_action(device_id, action, kwargs)
@@ -210,14 +210,14 @@ classDiagram
         +transfer_resource_to_another(resources, target, sites)
         +_setup_hardware_proxy(device, comm_device, read, write)
     }
-  
+
     %% 物料管理相关类
     class Deck {
         +name: str
         +children: List
         +assign_child_resource()
     }
-  
+
     class ResourceSynchronizer {
         <<abstract>>
         +workstation: WorkstationBase
@@ -225,23 +225,23 @@ classDiagram
         +sync_to_external(plr_resource)*
         +handle_external_change(change_info)*
     }
-  
+
     class BioyondResourceSynchronizer {
         +bioyond_api_client: BioyondV1RPC
         +sync_interval: int
         +last_sync_time: float
-    
+
         +initialize()
         +sync_from_external()
         +sync_to_external(resource)
         +handle_external_change(change_info)
     }
-  
+
     %% 硬件接口相关类
     class HardwareInterface {
         <<interface>>
     }
-  
+
     class BioyondV1RPC {
         +base_url: str
         +api_key: str
@@ -249,7 +249,7 @@ classDiagram
         +add_material()
         +material_inbound()
     }
-  
+
     %% 服务类
     class WorkstationHTTPService {
         +workstation: WorkstationBase
@@ -257,7 +257,7 @@ classDiagram
         +port: int
         +server: HTTPServer
         +running: bool
-    
+
         +start()
         +stop()
         +_handle_step_finish_report()
@@ -266,13 +266,13 @@ classDiagram
         +_handle_material_change_report()
         +_handle_error_handling_report()
     }
-  
+
     %% 具体实现类
     class BioyondWorkstation {
         +bioyond_config: Dict
         +workflow_mappings: Dict
         +workflow_sequence: List
-    
+
         +post_init(ros_node)
         +transfer_resource_to_another()
         +resource_tree_add(resources)
@@ -280,25 +280,25 @@ classDiagram
         +get_all_workflows()
         +get_bioyond_status()
     }
-  
+
     class ProtocolNode {
         +post_init(ros_node)
     }
-  
+
     %% 核心关系
     WorkstationBase o-- ROS2WorkstationNode : post_init关联
     WorkstationBase o-- WorkstationHTTPService : 可选服务
-  
+
     %% 物料管理侧
     WorkstationBase *-- Deck : deck
     WorkstationBase *-- ResourceSynchronizer : 可选组合
     ResourceSynchronizer <|-- BioyondResourceSynchronizer
-  
+
     %% 硬件接口侧
     WorkstationBase o-- HardwareInterface : hardware_interface
     HardwareInterface <|.. BioyondV1RPC : 实现
     BioyondResourceSynchronizer --> BioyondV1RPC : 使用
-  
+
     %% 继承关系
     BioyondWorkstation --|> WorkstationBase
     ProtocolNode --|> WorkstationBase
@@ -316,49 +316,49 @@ sequenceDiagram
     participant HW as HardwareInterface
     participant ROS as ROS2WorkstationNode
     participant HTTP as HTTPService
-  
+
     APP->>WS: 创建工作站实例(__init__)
     WS->>DECK: 初始化PLR Deck
     DECK->>DECK: 创建Warehouse等子资源
     DECK-->>WS: Deck创建完成
-  
+
     WS->>HW: 创建硬件接口(如BioyondV1RPC)
     HW->>HW: 建立连接(PLC/RPC/串口等)
     HW-->>WS: 硬件接口就绪
-  
+
     WS->>SYNC: 创建ResourceSynchronizer(可选)
     SYNC->>HW: 使用hardware_interface
     SYNC->>SYNC: 初始化同步配置
     SYNC-->>WS: 同步器创建完成
-  
+
     WS->>SYNC: sync_from_external()
     SYNC->>HW: 查询外部物料系统
     HW-->>SYNC: 返回物料数据
     SYNC->>DECK: 转换并添加到Deck
     SYNC-->>WS: 同步完成
-  
+
     Note over WS: __init__完成,等待ROS节点
-  
+
     APP->>ROS: 初始化ROS2WorkstationNode
     ROS->>ROS: 初始化子设备(children)
     ROS->>ROS: 创建Action客户端
     ROS->>ROS: 设置硬件接口代理
     ROS-->>APP: ROS节点就绪
-  
+
     APP->>WS: post_init(ros_node)
     WS->>WS: self._ros_node = ros_node
     WS->>ROS: update_resource([deck])
     ROS->>ROS: 上传物料到云端
     ROS-->>WS: 上传完成
-  
+
     WS->>HTTP: 创建WorkstationHTTPService(可选)
     HTTP->>HTTP: 启动HTTP服务器线程
     HTTP-->>WS: HTTP服务启动
-  
+
     WS-->>APP: 工作站完全就绪
 ```
 
-## 4. 工作流执行时序图（Protocol模式）
+## 4. 工作流执行时序图（Protocol 模式）
 
 ```{mermaid}
 sequenceDiagram
@@ -369,15 +369,15 @@ sequenceDiagram
     participant DECK as PLR Deck
     participant CLOUD as 云端资源管理
     participant DEV as 子设备
-  
+
     CLIENT->>ROS: 发送Protocol Action请求
     ROS->>ROS: execute_protocol回调
     ROS->>ROS: 从Goal提取参数
     ROS->>ROS: 调用protocol_steps_generator
     ROS->>ROS: 生成action步骤列表
-  
+
     ROS->>WS: 更新workflow_status = RUNNING
-  
+
     loop 执行每个步骤
         alt 调用子设备
             ROS->>ROS: execute_single_action(device_id, action, params)
@@ -398,19 +398,19 @@ sequenceDiagram
             end
             WS-->>ROS: 返回结果
         end
-    
+
         ROS->>DECK: 更新本地物料状态
         DECK->>DECK: 修改PLR资源属性
     end
-  
+
     ROS->>CLOUD: 同步物料到云端(可选)
     CLOUD-->>ROS: 同步完成
-  
+
     ROS->>WS: 更新workflow_status = COMPLETED
     ROS-->>CLIENT: 返回Protocol Result
 ```
 
-## 5. HTTP报送处理时序图
+## 5. HTTP 报送处理时序图
 
 ```{mermaid}
 sequenceDiagram
@@ -420,25 +420,25 @@ sequenceDiagram
     participant DECK as PLR Deck
     participant SYNC as ResourceSynchronizer
     participant CLOUD as 云端
-  
+
     EXT->>HTTP: POST /report/step_finish
     HTTP->>HTTP: 解析请求数据
     HTTP->>HTTP: 验证LIMS协议字段
     HTTP->>WS: process_step_finish_report(request)
-  
+
     WS->>WS: 增加接收计数(_reports_received_count++)
     WS->>WS: 记录步骤完成事件
     WS->>DECK: 更新相关物料状态(可选)
     DECK->>DECK: 修改PLR资源状态
-  
+
     WS->>WS: 保存报送记录到内存
-  
+
     WS-->>HTTP: 返回处理结果
     HTTP->>HTTP: 构造HTTP响应
     HTTP-->>EXT: 200 OK + acknowledgment_id
-  
+
     Note over EXT,CLOUD: 类似处理sample_finish, order_finish等报送
-  
+
     alt 物料变更报送
         EXT->>HTTP: POST /report/material_change
         HTTP->>WS: process_material_change_report(data)
@@ -463,7 +463,7 @@ sequenceDiagram
     participant HW as HardwareInterface
     participant HTTP as HTTPService
     participant LOG as 日志系统
-  
+
     alt 设备错误(ROS Action失败)
         DEV->>ROS: Action返回失败结果
         ROS->>ROS: 记录错误信息
@@ -475,7 +475,7 @@ sequenceDiagram
         WS->>WS: 记录错误历史
         WS->>LOG: 记录错误日志
     end
-  
+
     alt 关键错误需要停止
         WS->>ROS: stop_workflow(emergency=True)
         ROS->>ROS: 取消所有进行中的Action
@@ -487,44 +487,44 @@ sequenceDiagram
         WS->>ROS: 触发重试逻辑(可选)
         ROS->>DEV: 重新发送Action
     end
-  
+
     WS-->>HTTP: 返回错误处理结果
     HTTP-->>DEV: 200 OK + 处理状态
 ```
 
 ## 7. 典型工作站实现示例
 
-### 7.1 Bioyond集成工作站实现
+### 7.1 Bioyond 集成工作站实现
 
 ```python
 class BioyondWorkstation(WorkstationBase):
     def __init__(self, bioyond_config: Dict, deck: Deck, *args, **kwargs):
         # 初始化deck
         super().__init__(deck=deck, *args, **kwargs)
-      
+
         # 设置硬件接口为Bioyond RPC客户端
         self.hardware_interface = BioyondV1RPC(bioyond_config)
-      
+
         # 创建资源同步器
         self.resource_synchronizer = BioyondResourceSynchronizer(self)
-      
+
         # 从Bioyond同步物料到本地deck
         self.resource_synchronizer.sync_from_external()
-      
+
         # 配置工作流
         self.workflow_mappings = bioyond_config.get("workflow_mappings", {})
-  
+
     def post_init(self, ros_node: ROS2WorkstationNode):
         """ROS节点就绪后的初始化"""
         self._ros_node = ros_node
-      
+
         # 上传deck(包括所有物料)到云端
         ROS2DeviceNode.run_async_func(
-            self._ros_node.update_resource, 
-            True, 
+            self._ros_node.update_resource,
+            True,
             resources=[self.deck]
         )
-  
+
     def resource_tree_add(self, resources: List[ResourcePLR]):
         """添加物料并同步到Bioyond"""
         for resource in resources:
@@ -537,24 +537,24 @@ class BioyondWorkstation(WorkstationBase):
 ```python
 class ProtocolNode(WorkstationBase):
     """纯协议节点,不需要物料管理和外部通信"""
-  
+
     def __init__(self, deck: Optional[Deck] = None, *args, **kwargs):
         super().__init__(deck=deck, *args, **kwargs)
         # 不设置hardware_interface和resource_synchronizer
         # 所有功能通过子设备协同完成
-  
+
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
         # 不需要上传物料或其他初始化
 ```
 
-### 7.3 PLC直接控制工作站
+### 7.3 PLC 直接控制工作站
 
 ```python
 class PLCWorkstation(WorkstationBase):
     def __init__(self, plc_config: Dict, deck: Deck, *args, **kwargs):
         super().__init__(deck=deck, *args, **kwargs)
-      
+
         # 设置硬件接口为Modbus客户端
         from pymodbus.client import ModbusTcpClient
         self.hardware_interface = ModbusTcpClient(
@@ -562,7 +562,7 @@ class PLCWorkstation(WorkstationBase):
             port=plc_config["port"]
         )
         self.hardware_interface.connect()
-      
+
         # 定义支持的工作流
         self.supported_workflows = {
             "battery_assembly": WorkflowInfo(
@@ -574,49 +574,49 @@ class PLCWorkstation(WorkstationBase):
                 parameters_schema={"quantity": int, "model": str}
             )
         }
-  
+
     def execute_workflow(self, workflow_name: str, parameters: Dict):
         """通过PLC执行工作流"""
         workflow_id = self._get_workflow_id(workflow_name)
-      
+
         # 写入PLC寄存器启动工作流
         self.hardware_interface.write_register(100, workflow_id)
         self.hardware_interface.write_register(101, parameters["quantity"])
-      
+
         self.current_workflow_status = WorkflowStatus.RUNNING
         return True
 ```
 
 ## 8. 核心接口说明
 
-### 8.1 WorkstationBase核心属性
+### 8.1 WorkstationBase 核心属性
 
-| 属性                        | 类型                    | 说明                          |
-| --------------------------- | ----------------------- | ----------------------------- |
-| `_ros_node`               | ROS2WorkstationNode     | ROS节点引用，由post_init设置  |
-| `deck`                    | Deck                    | PyLabRobot Deck，本地物料系统 |
-| `plr_resources`           | Dict[str, PLRResource]  | 物料资源映射                  |
-| `resource_synchronizer`   | ResourceSynchronizer    | 外部物料同步器(可选)          |
-| `hardware_interface`      | Union[Any, str]         | 硬件接口或代理字符串          |
-| `current_workflow_status` | WorkflowStatus          | 当前工作流状态                |
-| `supported_workflows`     | Dict[str, WorkflowInfo] | 支持的工作流定义              |
+| 属性                      | 类型                    | 说明                            |
+| ------------------------- | ----------------------- | ------------------------------- |
+| `_ros_node`               | ROS2WorkstationNode     | ROS 节点引用，由 post_init 设置 |
+| `deck`                    | Deck                    | PyLabRobot Deck，本地物料系统   |
+| `plr_resources`           | Dict[str, PLRResource]  | 物料资源映射                    |
+| `resource_synchronizer`   | ResourceSynchronizer    | 外部物料同步器(可选)            |
+| `hardware_interface`      | Union[Any, str]         | 硬件接口或代理字符串            |
+| `current_workflow_status` | WorkflowStatus          | 当前工作流状态                  |
+| `supported_workflows`     | Dict[str, WorkflowInfo] | 支持的工作流定义                |
 
 ### 8.2 必须实现的方法
 
-- `post_init(ros_node)`: ROS节点就绪后的初始化，必须实现
+- `post_init(ros_node)`: ROS 节点就绪后的初始化，必须实现
 
 ### 8.3 硬件接口相关方法
 
 - `set_hardware_interface(interface)`: 设置硬件接口
 - `call_device_method(method, *args, **kwargs)`: 统一设备方法调用
-  - 支持直接模式: 直接调用hardware_interface的方法
-  - 支持代理模式: hardware_interface="proxy:device_id"通过ROS转发
+  - 支持直接模式: 直接调用 hardware_interface 的方法
+  - 支持代理模式: hardware_interface="proxy:device_id"通过 ROS 转发
 - `get_device_status()`: 获取设备状态
 - `is_device_available()`: 检查设备可用性
 
 ### 8.4 物料管理方法
 
-- `get_deck()`: 获取PLR Deck
+- `get_deck()`: 获取 PLR Deck
 - `get_all_resources()`: 获取所有物料
 - `find_resource_by_name(name)`: 按名称查找物料
 - `find_resources_by_type(type)`: 按类型查找物料
@@ -630,7 +630,7 @@ class PLCWorkstation(WorkstationBase):
 - `is_busy`: 检查是否忙碌(属性)
 - `workflow_runtime`: 获取运行时间(属性)
 
-### 8.6 可选的HTTP报送处理方法
+### 8.6 可选的 HTTP 报送处理方法
 
 - `process_step_finish_report()`: 步骤完成处理
 - `process_sample_finish_report()`: 样本完成处理
@@ -638,10 +638,10 @@ class PLCWorkstation(WorkstationBase):
 - `process_material_change_report()`: 物料变更处理
 - `handle_external_error()`: 错误处理
 
-### 8.7 ROS2WorkstationNode核心方法
+### 8.7 ROS2WorkstationNode 核心方法
 
 - `initialize_device(device_id, config)`: 初始化子设备
-- `create_ros_action_server(action_name, mapping)`: 创建Action服务器
+- `create_ros_action_server(action_name, mapping)`: 创建 Action 服务器
 - `execute_single_action(device_id, action, kwargs)`: 执行单个动作
 - `update_resource(resources)`: 同步物料到云端
 - `transfer_resource_to_another(...)`: 跨设备物料转移
@@ -698,7 +698,7 @@ workstation = BioyondWorkstation(
                 "config": {...}
             },
             "gripper_1": {
-                "type": "device", 
+                "type": "device",
                 "driver": "RobotiqGripperDriver",
                 "communication": "io_modbus_1",
                 "config": {...}
@@ -720,7 +720,7 @@ workstation = BioyondWorkstation(
 }
 ```
 
-### 9.3 HTTP服务配置
+### 9.3 HTTP 服务配置
 
 ```python
 from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
@@ -741,31 +741,31 @@ http_service.start()
 ### 10.1 清晰的职责分离
 
 - **WorkstationBase**: 负责物料管理(deck)、硬件接口(hardware_interface)、工作流状态管理
-- **ROS2WorkstationNode**: 负责子设备管理、Protocol执行、云端物料同步
-- **ResourceSynchronizer**: 可选的外部物料系统同步(如Bioyond)
-- **WorkstationHTTPService**: 可选的HTTP报送接收服务
+- **ROS2WorkstationNode**: 负责子设备管理、Protocol 执行、云端物料同步
+- **ResourceSynchronizer**: 可选的外部物料系统同步(如 Bioyond)
+- **WorkstationHTTPService**: 可选的 HTTP 报送接收服务
 
 ### 10.2 灵活的硬件接口模式
 
-1. **直接模式**: hardware_interface是具体对象(如BioyondV1RPC、ModbusClient)
-2. **代理模式**: hardware_interface="proxy:device_id"，通过ROS节点转发到子设备
+1. **直接模式**: hardware_interface 是具体对象(如 BioyondV1RPC、ModbusClient)
+2. **代理模式**: hardware_interface="proxy:device_id"，通过 ROS 节点转发到子设备
 3. **混合模式**: 工作站有自己的接口，同时管理多个子设备
 
 ### 10.3 统一的物料系统
 
-- 基于PyLabRobot Deck的标准化物料表示
-- 通过ResourceSynchronizer实现与外部系统(如Bioyond、LIMS)的双向同步
-- 通过ROS2WorkstationNode实现与云端的物料状态同步
+- 基于 PyLabRobot Deck 的标准化物料表示
+- 通过 ResourceSynchronizer 实现与外部系统(如 Bioyond、LIMS)的双向同步
+- 通过 ROS2WorkstationNode 实现与云端的物料状态同步
 
-### 10.4 Protocol驱动的工作流
+### 10.4 Protocol 驱动的工作流
 
-- ROS2WorkstationNode负责Protocol的执行和步骤管理
-- 支持子设备协同(通过Action Client调用)
-- 支持工作站直接控制(通过hardware_interface)
+- ROS2WorkstationNode 负责 Protocol 的执行和步骤管理
+- 支持子设备协同(通过 Action Client 调用)
+- 支持工作站直接控制(通过 hardware_interface)
 
-### 10.5 可选的HTTP报送服务
+### 10.5 可选的 HTTP 报送服务
 
-- 基于LIMS协议规范的统一报送接口
+- 基于 LIMS 协议规范的统一报送接口
 - 支持步骤完成、样本完成、任务完成、物料变更等多种报送类型
 - 与工作站解耦，可独立启停
 

docs/developer_guide/http_api.md

@@ -0,0 +1,334 @@
+# HTTP API 指南
+
+本文档介绍如何通过 HTTP API 与 Uni-Lab-OS 进行交互，包括查询设备、提交任务和获取结果。
+
+## 概述
+
+Uni-Lab-OS 提供 RESTful HTTP API，允许外部系统通过标准 HTTP 请求控制实验室设备。API 基于 FastAPI 构建，默认运行在 `http://localhost:8002`。
+
+### 基础信息
+
+- **Base URL**: `http://localhost:8002/api/v1`
+- **Content-Type**: `application/json`
+- **响应格式**: JSON
+
+### 通用响应结构
+
+```json
+{
+    "code": 0,
+    "data": { ... },
+    "message": "success"
+}
+```
+
+| 字段      | 类型   | 说明               |
+| --------- | ------ | ------------------ |
+| `code`    | int    | 状态码，0 表示成功 |
+| `data`    | object | 响应数据           |
+| `message` | string | 响应消息           |
+
+## 快速开始
+
+以下是一个完整的工作流示例：查询设备 → 获取动作 → 提交任务 → 获取结果。
+
+### 步骤 1: 获取在线设备
+
+```bash
+curl -X GET "http://localhost:8002/api/v1/online-devices"
+```
+
+**响应示例**:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "online_devices": {
+      "host_node": {
+        "device_key": "/host_node",
+        "namespace": "",
+        "machine_name": "本地",
+        "uuid": "xxx-xxx-xxx",
+        "node_name": "host_node"
+      }
+    },
+    "total_count": 1,
+    "timestamp": 1732612345.123
+  },
+  "message": "success"
+}
+```
+
+### 步骤 2: 获取设备可用动作
+
+```bash
+curl -X GET "http://localhost:8002/api/v1/devices/host_node/actions"
+```
+
+**响应示例**:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "device_id": "host_node",
+    "actions": {
+      "test_latency": {
+        "type_name": "unilabos_msgs.action._empty_in.EmptyIn",
+        "type_name_convert": "unilabos_msgs/action/_empty_in/EmptyIn",
+        "action_path": "/devices/host_node/test_latency",
+        "goal_info": "{}",
+        "is_busy": false,
+        "current_job_id": null
+      },
+      "create_resource": {
+        "type_name": "unilabos_msgs.action._resource_create_from_outer_easy.ResourceCreateFromOuterEasy",
+        "action_path": "/devices/host_node/create_resource",
+        "goal_info": "{res_id: '', device_id: '', class_name: '', ...}",
+        "is_busy": false,
+        "current_job_id": null
+      }
+    },
+    "action_count": 5
+  },
+  "message": "success"
+}
+```
+
+**动作状态字段说明**:
+
+| 字段             | 说明                          |
+| ---------------- | ----------------------------- |
+| `type_name`      | 动作类型的完整名称            |
+| `action_path`    | ROS2 动作路径                 |
+| `goal_info`      | 动作参数模板                  |
+| `is_busy`        | 动作是否正在执行              |
+| `current_job_id` | 当前执行的任务 ID（如果繁忙） |
+
+### 步骤 3: 提交任务
+
+```bash
+curl -X POST "http://localhost:8002/api/v1/job/add" \
+  -H "Content-Type: application/json" \
+  -d '{"device_id":"host_node","action":"test_latency","action_args":{}}'
+```
+
+**请求体**:
+
+```json
+{
+  "device_id": "host_node",
+  "action": "test_latency",
+  "action_args": {}
+}
+```
+
+**请求参数说明**:
+
+| 字段          | 类型   | 必填 | 说明                               |
+| ------------- | ------ | ---- | ---------------------------------- |
+| `device_id`   | string | ✓    | 目标设备 ID                        |
+| `action`      | string | ✓    | 动作名称                           |
+| `action_args` | object | ✓    | 动作参数（根据动作类型不同而变化） |
+
+**响应示例**:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "jobId": "b6acb586-733a-42ab-9f73-55c9a52aa8bd",
+    "status": 1,
+    "result": {}
+  },
+  "message": "success"
+}
+```
+
+**任务状态码**:
+
+| 状态码 | 含义      | 说明                           |
+| ------ | --------- | ------------------------------ |
+| 0      | UNKNOWN   | 未知状态                       |
+| 1      | ACCEPTED  | 任务已接受，等待执行           |
+| 2      | EXECUTING | 任务执行中                     |
+| 3      | CANCELING | 任务取消中                     |
+| 4      | SUCCEEDED | 任务成功完成                   |
+| 5      | CANCELED  | 任务已取消                     |
+| 6      | ABORTED   | 任务中止（设备繁忙或执行失败） |
+
+### 步骤 4: 查询任务状态和结果
+
+```bash
+curl -X GET "http://localhost:8002/api/v1/job/b6acb586-733a-42ab-9f73-55c9a52aa8bd/status"
+```
+
+**响应示例（执行中）**:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "jobId": "b6acb586-733a-42ab-9f73-55c9a52aa8bd",
+    "status": 2,
+    "result": {}
+  },
+  "message": "success"
+}
+```
+
+**响应示例（执行完成）**:
+
+```json
+{
+  "code": 0,
+  "data": {
+    "jobId": "b6acb586-733a-42ab-9f73-55c9a52aa8bd",
+    "status": 4,
+    "result": {
+      "error": "",
+      "suc": true,
+      "return_value": {
+        "avg_rtt_ms": 103.99,
+        "avg_time_diff_ms": 7181.55,
+        "max_time_error_ms": 7210.57,
+        "task_delay_ms": -1,
+        "raw_delay_ms": 33.19,
+        "test_count": 5,
+        "status": "success"
+      }
+    }
+  },
+  "message": "success"
+}
+```
+
+> **注意**: 任务结果在首次查询后会被自动删除，请确保保存返回的结果数据。
+
+## API 端点列表
+
+### 设备相关
+
+| 端点                                                       | 方法 | 说明                   |
+| ---------------------------------------------------------- | ---- | ---------------------- |
+| `/api/v1/online-devices`                                   | GET  | 获取在线设备列表       |
+| `/api/v1/devices`                                          | GET  | 获取设备配置           |
+| `/api/v1/devices/{device_id}/actions`                      | GET  | 获取指定设备的可用动作 |
+| `/api/v1/devices/{device_id}/actions/{action_name}/schema` | GET  | 获取动作参数 Schema    |
+| `/api/v1/actions`                                          | GET  | 获取所有设备的可用动作 |
+
+### 任务相关
+
+| 端点                          | 方法 | 说明               |
+| ----------------------------- | ---- | ------------------ |
+| `/api/v1/job/add`             | POST | 提交新任务         |
+| `/api/v1/job/{job_id}/status` | GET  | 查询任务状态和结果 |
+
+### 资源相关
+
+| 端点                | 方法 | 说明         |
+| ------------------- | ---- | ------------ |
+| `/api/v1/resources` | GET  | 获取资源列表 |
+
+## 常见动作示例
+
+### test_latency - 延迟测试
+
+测试系统延迟，无需参数。
+
+```bash
+curl -X POST "http://localhost:8002/api/v1/job/add" \
+  -H "Content-Type: application/json" \
+  -d '{"device_id":"host_node","action":"test_latency","action_args":{}}'
+```
+
+### create_resource - 创建资源
+
+在设备上创建新资源。
+
+```bash
+curl -X POST "http://localhost:8002/api/v1/job/add" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "device_id": "host_node",
+    "action": "create_resource",
+    "action_args": {
+        "res_id": "my_plate",
+        "device_id": "host_node",
+        "class_name": "Plate",
+        "parent": "deck",
+        "bind_locations": {"x": 0, "y": 0, "z": 0}
+    }
+}'
+```
+
+## 错误处理
+
+### 设备繁忙
+
+当设备正在执行其他任务时，提交新任务会返回 `status: 6`（ABORTED）：
+
+```json
+{
+  "code": 0,
+  "data": {
+    "jobId": "xxx",
+    "status": 6,
+    "result": {}
+  },
+  "message": "success"
+}
+```
+
+此时应等待当前任务完成后重试，或使用 `/devices/{device_id}/actions` 检查动作的 `is_busy` 状态。
+
+### 参数错误
+
+```json
+{
+    "code": 2002,
+    "data": { ... },
+    "message": "device_id is required"
+}
+```
+
+## 轮询策略
+
+推荐的任务状态轮询策略：
+
+```python
+import requests
+import time
+
+def wait_for_job(job_id, timeout=60, interval=0.5):
+    """等待任务完成并返回结果"""
+    start_time = time.time()
+
+    while time.time() - start_time < timeout:
+        response = requests.get(f"http://localhost:8002/api/v1/job/{job_id}/status")
+        data = response.json()["data"]
+
+        status = data["status"]
+        if status in (4, 5, 6):  # SUCCEEDED, CANCELED, ABORTED
+            return data
+
+        time.sleep(interval)
+
+    raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+
+# 使用示例
+response = requests.post(
+    "http://localhost:8002/api/v1/job/add",
+    json={"device_id": "host_node", "action": "test_latency", "action_args": {}}
+)
+job_id = response.json()["data"]["jobId"]
+result = wait_for_job(job_id)
+print(result)
+```
+
+## 相关文档
+
+- [设备注册指南](add_device.md)
+- [动作定义指南](add_action.md)
+- [网络架构概述](networking_overview.md)

docs/developer_guide/networking_overview.md

@@ -592,4 +592,3 @@ ros2 topic list
 - [ROS2 网络配置](https://docs.ros.org/en/humble/Tutorials/Advanced/Networking.html)
 - [DDS 配置](https://fast-dds.docs.eprosima.com/)
 - Uni-Lab 云平台文档
-

docs/index.md

@@ -7,3 +7,17 @@ Uni-Lab-OS 是一个开源的实验室自动化操作系统，提供统一的设
 
 intro.md
 ```
+
+## 开发者指南
+
+```{toctree}
+:maxdepth: 2
+
+developer_guide/http_api.md
+developer_guide/networking_overview.md
+developer_guide/add_device.md
+developer_guide/add_action.md
+developer_guide/add_registry.md
+developer_guide/add_yaml.md
+developer_guide/action_includes.md
+```

docs/user_guide/installation.md

@@ -317,45 +317,6 @@ unilab --help
 
 如果所有命令都正常输出，说明开发环境配置成功！
 
-### 开发工具推荐
-
-#### IDE
-
-- **PyCharm Professional**: 强大的 Python IDE，支持远程调试
-- **VS Code**: 轻量级，配合 Python 扩展使用
-- **Vim/Emacs**: 适合终端开发
-
-#### 推荐的 VS Code 扩展
-
-- Python
-- Pylance
-- ROS
-- URDF
-- YAML
-
-#### 调试工具
-
-```bash
-# 安装调试工具
-pip install ipdb pytest pytest-cov -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-
-# 代码质量检查
-pip install black flake8 mypy -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-```
-
-### 设置 pre-commit 钩子（可选）
-
-```bash
-# 安装 pre-commit
-pip install pre-commit -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
-
-# 设置钩子
-pre-commit install
-
-# 手动运行检查
-pre-commit run --all-files
-```
-
 ---
 
 ## 验证安装

fix_datatype.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import re
+
+filepath = r'd:\UniLab\Uni-Lab-OS\unilabos\device_comms\modbus_plc\modbus.py'
+
+with open(filepath, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+# Replace the DataType placeholder with actual enum
+find_pattern = r'# DataType will be accessed via client instance.*?DataType = None  # Placeholder.*?\n'
+replacement = '''# Define DataType enum for pymodbus 2.5.3 compatibility
+class DataType(Enum):
+    INT16 = "int16"
+    UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
+    INT64 = "int64"
+    UINT64 = "uint64"
+    FLOAT32 = "float32"
+    FLOAT64 = "float64"
+    STRING = "string"
+    BOOL = "bool"
+
+'''
+
+new_content = re.sub(find_pattern, replacement, content, flags=re.DOTALL)
+
+with open(filepath, 'w', encoding='utf-8') as f:
+    f.write(new_content)
+
+print('File updated successfully!')

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": []
+}
+
+    

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

scripts/workflow.py

@@ -2,7 +2,6 @@ import json
 import logging
 import traceback
 import uuid
-import xml.etree.ElementTree as ET
 from typing import Any, Dict, List
 
 import networkx as nx
@@ -25,7 +24,15 @@ class SimpleGraph:
 
     def add_edge(self, source, target, **attrs):
         """添加边"""
-        edge = {"source": source, "target": target, **attrs}
+        # edge = {"source": source, "target": target, **attrs}
+        edge = {
+            "source": source, "target": target,
+            "source_node_uuid": source,
+            "target_node_uuid": target,
+            "source_handle_io": "source",
+            "target_handle_io": "target",
+            **attrs
+        }
         self.edges.append(edge)
 
     def to_dict(self):
@@ -42,6 +49,7 @@ class SimpleGraph:
             "multigraph": False,
             "graph": {},
             "nodes": nodes_list,
+            "edges": self.edges,
             "links": self.edges,
         }
 
@@ -58,495 +66,8 @@ def extract_json_from_markdown(text: str) -> str:
     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(

setup.py

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

test/experiments/reaction_station_bioyond.json

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

test/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,13 +12,13 @@ lab_registry.setup()
 
 
 type_mapping = {
-    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
-    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "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_resourcetreeset.py

@@ -1,3 +1,4 @@
+from ast import If
 import pytest
 import json
 import os
@@ -8,18 +9,16 @@ 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 = {
-    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
-    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+    "加样头(大)": ("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"),
 }
 
 
@@ -57,12 +56,20 @@ def bioyond_materials_liquidhandling_2() -> list[dict]:
     "bioyond_materials_reaction",
     "bioyond_materials_liquidhandling_1",
 ])
-def test_resourcetreeset_from_plr(materials_fixture, request) -> list[dict]:
-    materials = request.getfixturevalue(materials_fixture)
-    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
+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(deck.summary())
+    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/merge_workflow.py

@@ -0,0 +1,35 @@
+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 unilabos.workflow.convert_from_json import (
+    convert_from_json,
+    normalize_steps as _normalize_steps,
+    normalize_labware as _normalize_labware,
+)
+from unilabos.workflow.common import draw_protocol_graph_with_ports
+
+
+@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")
+
+    graph = convert_from_json(data_path, 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/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.11"
+__version__ = "0.10.12"

unilabos/app/communication.py

@@ -141,7 +141,7 @@ class CommunicationClientFactory:
         """
         if cls._client_cache is None:
             cls._client_cache = cls.create_client(protocol)
-            logger.info(f"[CommunicationFactory] Created {type(cls._client_cache).__name__} client")
+            logger.trace(f"[CommunicationFactory] Created {type(cls._client_cache).__name__} client")
 
         return cls._client_cache
 

unilabos/app/main.py

@@ -20,6 +20,7 @@ if unilabos_dir not in sys.path:
 from unilabos.utils.banner_print import print_status, print_unilab_banner
 from unilabos.config.config import load_config, BasicConfig, HTTPConfig
 
+
 def load_config_from_file(config_path):
     if config_path is None:
         config_path = os.environ.get("UNILABOS_BASICCONFIG_CONFIG_PATH", None)
@@ -41,7 +42,7 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
     for i, arg in enumerate(sys.argv):
         for option_string in option_strings:
             if arg.startswith(option_string):
-                new_arg = arg[:2] + arg[2:len(option_string)].replace("-", "_") + arg[len(option_string):]
+                new_arg = arg[:2] + arg[2 : len(option_string)].replace("-", "_") + arg[len(option_string) :]
                 sys.argv[i] = new_arg
                 break
 
@@ -49,6 +50,8 @@ def convert_argv_dashes_to_underscores(args: argparse.ArgumentParser):
 def parse_args():
     """解析命令行参数"""
     parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
+    subparsers = parser.add_subparsers(title="Valid subcommands", dest="command")
+
     parser.add_argument("-g", "--graph", help="Physical setup graph file path.")
     parser.add_argument("-c", "--controllers", default=None, help="Controllers config file path.")
     parser.add_argument(
@@ -153,21 +156,54 @@ def parse_args():
         default=False,
         help="Complete registry information",
     )
+    # workflow upload subcommand
+    workflow_parser = subparsers.add_parser(
+        "workflow_upload",
+        aliases=["wf"],
+        help="Upload workflow from xdl/json/python files",
+    )
+    workflow_parser.add_argument(
+        "-f",
+        "--workflow_file",
+        type=str,
+        required=True,
+        help="Path to the workflow file (JSON format)",
+    )
+    workflow_parser.add_argument(
+        "-n",
+        "--workflow_name",
+        type=str,
+        default=None,
+        help="Workflow name, if not provided will use the name from file or filename",
+    )
+    workflow_parser.add_argument(
+        "--tags",
+        type=str,
+        nargs="*",
+        default=[],
+        help="Tags for the workflow (space-separated)",
+    )
+    workflow_parser.add_argument(
+        "--published",
+        action="store_true",
+        default=False,
+        help="Whether to publish the workflow (default: False)",
+    )
     return parser
 
 
 def main():
     """主函数"""
     # 解析命令行参数
-    args = parse_args()
-    convert_argv_dashes_to_underscores(args)
-    args_dict = vars(args.parse_args())
+    parser = parse_args()
+    convert_argv_dashes_to_underscores(parser)
+    args = parser.parse_args()
+    args_dict = vars(args)
 
     # 环境检查 - 检查并自动安装必需的包 (可选)
     if not args_dict.get("skip_env_check", False):
         from unilabos.utils.environment_check import check_environment
 
-        print_status("正在进行环境依赖检查...", "info")
         if not check_environment(auto_install=True):
             print_status("环境检查失败，程序退出", "error")
             os._exit(1)
@@ -218,19 +254,20 @@ def main():
 
     if hasattr(BasicConfig, "log_level"):
         logger.info(f"Log level set to '{BasicConfig.log_level}' from config file.")
-        configure_logger(loglevel=BasicConfig.log_level)
+    configure_logger(loglevel=BasicConfig.log_level, working_dir=working_dir)
 
-    if args_dict["addr"] == "test":
-        print_status("使用测试环境地址", "info")
-        HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
-    elif args_dict["addr"] == "uat":
-        print_status("使用uat环境地址", "info")
-        HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
-    elif args_dict["addr"] == "local":
-        print_status("使用本地环境地址", "info")
-        HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
-    else:
-        HTTPConfig.remote_addr = args_dict.get("addr", "")
+    if args.addr != parser.get_default("addr"):
+        if args.addr == "test":
+            print_status("使用测试环境地址", "info")
+            HTTPConfig.remote_addr = "https://uni-lab.test.bohrium.com/api/v1"
+        elif args.addr == "uat":
+            print_status("使用uat环境地址", "info")
+            HTTPConfig.remote_addr = "https://uni-lab.uat.bohrium.com/api/v1"
+        elif args.addr == "local":
+            print_status("使用本地环境地址", "info")
+            HTTPConfig.remote_addr = "http://127.0.0.1:48197/api/v1"
+        else:
+            HTTPConfig.remote_addr = args.addr
 
     # 设置BasicConfig参数
     if args_dict.get("ak", ""):
@@ -239,9 +276,12 @@ def main():
     if args_dict.get("sk", ""):
         BasicConfig.sk = args_dict.get("sk", "")
         print_status("传入了sk参数，优先采用传入参数！", "info")
+    BasicConfig.working_dir = working_dir
+
+    workflow_upload = args_dict.get("command") in ("workflow_upload", "wf")
 
     # 使用远程资源启动
-    if args_dict["use_remote_resource"]:
+    if not workflow_upload and args_dict["use_remote_resource"]:
         print_status("使用远程资源启动", "info")
         from unilabos.app.web import http_client
 
@@ -254,7 +294,6 @@ def main():
 
     BasicConfig.port = args_dict["port"] if args_dict["port"] else BasicConfig.port
     BasicConfig.disable_browser = args_dict["disable_browser"] or BasicConfig.disable_browser
-    BasicConfig.working_dir = working_dir
     BasicConfig.is_host_mode = not args_dict.get("is_slave", False)
     BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
     BasicConfig.upload_registry = args_dict.get("upload_registry", False)
@@ -283,9 +322,31 @@ def main():
 
     # 注册表
     lab_registry = build_registry(
-        args_dict["registry_path"], args_dict.get("complete_registry", False), args_dict["upload_registry"]
+        args_dict["registry_path"], args_dict.get("complete_registry", False), BasicConfig.upload_registry
     )
 
+    if BasicConfig.upload_registry:
+        # 设备注册到服务端 - 需要 ak 和 sk
+        if BasicConfig.ak and BasicConfig.sk:
+            print_status("开始注册设备到服务端...", "info")
+            try:
+                register_devices_and_resources(lab_registry)
+                print_status("设备注册完成", "info")
+            except Exception as e:
+                print_status(f"设备注册失败: {e}", "error")
+        else:
+            print_status("未提供 ak 和 sk，跳过设备注册", "info")
+    else:
+        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
+
+    # 处理 workflow_upload 子命令
+    if workflow_upload:
+        from unilabos.workflow.wf_utils import handle_workflow_upload_command
+
+        handle_workflow_upload_command(args_dict)
+        print_status("工作流上传完成，程序退出", "info")
+        os._exit(0)
+
     if not BasicConfig.ak or not BasicConfig.sk:
         print_status("后续运行必须拥有一个实验室，请前往 https://uni-lab.bohrium.com 注册实验室！", "warning")
         os._exit(1)
@@ -362,20 +423,6 @@ def main():
     args_dict["devices_config"] = resource_tree_set
     args_dict["graph"] = graph_res.physical_setup_graph
 
-    if BasicConfig.upload_registry:
-        # 设备注册到服务端 - 需要 ak 和 sk
-        if BasicConfig.ak and BasicConfig.sk:
-            print_status("开始注册设备到服务端...", "info")
-            try:
-                register_devices_and_resources(lab_registry)
-                print_status("设备注册完成", "info")
-            except Exception as e:
-                print_status(f"设备注册失败: {e}", "error")
-        else:
-            print_status("未提供 ak 和 sk，跳过设备注册", "info")
-    else:
-        print_status("本次启动注册表不报送云端，如果您需要联网调试，请在启动命令增加--upload_registry", "warning")
-
     if args_dict["controllers"] is not None:
         args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
     else:
@@ -390,6 +437,7 @@ def main():
         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)
@@ -431,16 +479,13 @@ def main():
                 resource_visualization.start()
             except OSError as e:
                 if "AMENT_PREFIX_PATH" in str(e):
-                    print_status(
-                        f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}",
-                        "warning"
-                    )
+                    print_status(f"ROS 2环境未正确设置，跳过3D可视化启动。错误详情: {e}", "warning")
                     print_status(
                         "建议解决方案：\n"
                         "1. 激活Conda环境: conda activate unilab\n"
                         "2. 或使用 --backend simple 参数\n"
                         "3. 或使用 --visual disable 参数禁用可视化",
-                        "info"
+                        "info",
                     )
                 else:
                     raise
@@ -450,13 +495,13 @@ def main():
             start_backend(**args_dict)
             start_server(
                 open_browser=not args_dict["disable_browser"],
-                port=args_dict["port"],
+                port=BasicConfig.port,
             )
     else:
         start_backend(**args_dict)
         start_server(
             open_browser=not args_dict["disable_browser"],
-            port=args_dict["port"],
+            port=BasicConfig.port,
         )
 
 

unilabos/app/model.py

@@ -51,21 +51,25 @@ class Resp(BaseModel):
 class JobAddReq(BaseModel):
     device_id: str = Field(examples=["Gripper"], description="device id")
     action: str = Field(examples=["_execute_driver_command_async"], description="action name", default="")
-    action_type: str = Field(examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action name", default="")
-    action_args: dict = Field(examples=[{'string': 'string'}], description="action name", default="")
-    task_id: str = Field(examples=["task_id"], description="task uuid")
-    job_id: str = Field(examples=["job_id"], description="goal uuid")
-    node_id: str = Field(examples=["node_id"], description="node uuid")
-    server_info: dict = Field(examples=[{"send_timestamp": 1717000000.0}], description="server info")
+    action_type: str = Field(
+        examples=["unilabos_msgs.action._str_single_input.StrSingleInput"], description="action type", default=""
+    )
+    action_args: dict = Field(examples=[{"string": "string"}], description="action arguments", default_factory=dict)
+    task_id: str = Field(examples=["task_id"], description="task uuid (auto-generated if empty)", default="")
+    job_id: str = Field(examples=["job_id"], description="goal uuid (auto-generated if empty)", default="")
+    node_id: str = Field(examples=["node_id"], description="node uuid", default="")
+    server_info: dict = Field(
+        examples=[{"send_timestamp": 1717000000.0}],
+        description="server info (auto-generated if empty)",
+        default_factory=dict,
+    )
 
-    data: dict = Field(examples=[{"position": 30, "torque": 5, "action": "push_to"}], default={})
+    data: dict = Field(examples=[{"position": 30, "torque": 5, "action": "push_to"}], default_factory=dict)
 
 
 class JobStepFinishReq(BaseModel):
     token: str = Field(examples=["030944"], description="token")
-    request_time: str = Field(
-        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
-    )
+    request_time: str = Field(examples=["2024-12-12 12:12:12.xxx"], description="requestTime")
     data: dict = Field(
         examples=[
             {
@@ -83,9 +87,7 @@ class JobStepFinishReq(BaseModel):
 
 class JobPreintakeFinishReq(BaseModel):
     token: str = Field(examples=["030944"], description="token")
-    request_time: str = Field(
-        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
-    )
+    request_time: str = Field(examples=["2024-12-12 12:12:12.xxx"], description="requestTime")
     data: dict = Field(
         examples=[
             {
@@ -102,9 +104,7 @@ class JobPreintakeFinishReq(BaseModel):
 
 class JobFinishReq(BaseModel):
     token: str = Field(examples=["030944"], description="token")
-    request_time: str = Field(
-        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
-    )
+    request_time: str = Field(examples=["2024-12-12 12:12:12.xxx"], description="requestTime")
     data: dict = Field(
         examples=[
             {
@@ -133,6 +133,10 @@ class JobData(BaseModel):
         default=0,
         description="0:UNKNOWN, 1:ACCEPTED, 2:EXECUTING, 3:CANCELING, 4:SUCCEEDED, 5:CANCELED, 6:ABORTED",
     )
+    result: dict = Field(
+        default_factory=dict,
+        description="Job result data (available when status is SUCCEEDED/CANCELED/ABORTED)",
+    )
 
 
 class JobStatusResp(Resp):

unilabos/app/oss_upload.py

@@ -1,161 +1,158 @@
 import argparse
 import os
 import time
-from typing import Dict, Optional, Tuple
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
 
 import requests
 
-from unilabos.config.config import OSSUploadConfig
+from unilabos.app.web.client import http_client, HTTPClient
+from unilabos.utils import logger
 
 
-def _init_upload(file_path: str, oss_path: str, filename: Optional[str] = None,
-                process_key: str = "file-upload", device_id: str = "default",
-                expires_hours: int = 1) -> Tuple[bool, Dict]:
+def _get_oss_token(
+    filename: str,
+    driver_name: str = "default",
+    exp_type: str = "default",
+    client: Optional[HTTPClient] = None,
+) -> Tuple[bool, Dict]:
     """
-    初始化上传过程
+    获取OSS上传Token
 
     Args:
-        file_path: 本地文件路径
-        oss_path: OSS目标路径
-        filename: 文件名，如果为None则使用file_path的文件名
-        process_key: 处理键
-        device_id: 设备ID
-        expires_hours: 链接过期小时数
+        filename: 文件名
+        driver_name: 驱动名称
+        exp_type: 实验类型
+        client: HTTPClient实例，如果不提供则使用默认的http_client
 
     Returns:
-        (成功标志, 响应数据)
+        (成功标志, Token数据字典包含token/path/host/expires)
     """
-    if filename is None:
-        filename = os.path.basename(file_path)
+    # 使用提供的client或默认的http_client
+    if client is None:
+        client = http_client
 
-    # 构造初始化请求
-    url = f"{OSSUploadConfig.api_host}{OSSUploadConfig.init_endpoint}"
-    headers = {
-        "Authorization": OSSUploadConfig.authorization,
-        "Content-Type": "application/json"
-    }
+    # 构造scene参数: driver_name-exp_type
+    sub_path = f"{driver_name}-{exp_type}"
 
-    payload = {
-        "device_id": device_id,
-        "process_key": process_key,
-        "filename": filename,
-        "path": oss_path,
-        "expires_hours": expires_hours
-    }
+    # 构造请求URL，使用client的remote_addr（已包含/api/v1/）
+    url = f"{client.remote_addr}/applications/token"
+    params = {"sub_path": sub_path, "filename": filename, "scene": "job"}
 
     try:
-        response = requests.post(url, headers=headers, json=payload)
-        if response.status_code == 201:
-            result = response.json()
-            if result.get("code") == "10000":
-                return True, result.get("data", {})
+        logger.info(f"[OSS] 请求预签名URL: sub_path={sub_path}, filename={filename}")
+        response = requests.get(url, params=params, headers={"Authorization": f"Lab {client.auth}"}, timeout=10)
 
-        print(f"初始化上传失败: {response.status_code}, {response.text}")
+        if response.status_code == 200:
+            result = response.json()
+            if result.get("code") == 0:
+                data = result.get("data", {})
+
+                # 转换expires时间戳为可读格式
+                expires_timestamp = data.get("expires", 0)
+                expires_datetime = datetime.fromtimestamp(expires_timestamp)
+                expires_str = expires_datetime.strftime("%Y-%m-%d %H:%M:%S")
+
+                logger.info(f"[OSS] 获取预签名URL成功")
+                logger.info(f"[OSS]   - URL: {data.get('url', 'N/A')}")
+                logger.info(f"[OSS]   - Expires: {expires_str} (timestamp: {expires_timestamp})")
+
+                return True, data
+
+        logger.error(f"[OSS] 获取预签名URL失败: {response.status_code}, {response.text}")
         return False, {}
     except Exception as e:
-        print(f"初始化上传异常: {str(e)}")
+        logger.error(f"[OSS] 获取预签名URL异常: {str(e)}")
         return False, {}
 
 
 def _put_upload(file_path: str, upload_url: str) -> bool:
     """
-    执行PUT上传
+    使用预签名URL上传文件到OSS
 
     Args:
         file_path: 本地文件路径
-        upload_url: 上传URL
+        upload_url: 完整的预签名上传URL
 
     Returns:
         是否成功
     """
     try:
+        logger.info(f"[OSS] 开始上传文件: {file_path}")
+
         with open(file_path, "rb") as f:
-            response = requests.put(upload_url, data=f)
+            # 使用预签名URL上传，不需要额外的认证header
+            response = requests.put(upload_url, data=f, timeout=300)
+
             if response.status_code == 200:
+                logger.info(f"[OSS] 文件上传成功")
                 return True
 
-        print(f"PUT上传失败: {response.status_code}, {response.text}")
+        logger.error(f"[OSS] 上传失败: {response.status_code}")
+        logger.error(f"[OSS] 响应内容: {response.text[:500] if response.text else '无响应内容'}")
         return False
     except Exception as e:
-        print(f"PUT上传异常: {str(e)}")
+        logger.error(f"[OSS] 上传异常: {str(e)}")
         return False
 
 
-def _complete_upload(uuid: str) -> bool:
-    """
-    完成上传过程
-
-    Args:
-        uuid: 上传的UUID
-
-    Returns:
-        是否成功
-    """
-    url = f"{OSSUploadConfig.api_host}{OSSUploadConfig.complete_endpoint}"
-    headers = {
-        "Authorization": OSSUploadConfig.authorization,
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "uuid": uuid
-    }
-
-    try:
-        response = requests.post(url, headers=headers, json=payload)
-        if response.status_code == 200:
-            result = response.json()
-            if result.get("code") == "10000":
-                return True
-
-        print(f"完成上传失败: {response.status_code}, {response.text}")
-        return False
-    except Exception as e:
-        print(f"完成上传异常: {str(e)}")
-        return False
-
-
-def oss_upload(file_path: str, oss_path: str, filename: Optional[str] = None,
-              process_key: str = "file-upload", device_id: str = "default") -> bool:
+def oss_upload(
+    file_path: Union[str, Path],
+    filename: Optional[str] = None,
+    driver_name: str = "default",
+    exp_type: str = "default",
+    max_retries: int = 3,
+    client: Optional[HTTPClient] = None,
+) -> Dict:
     """
     文件上传主函数，包含重试机制
 
     Args:
         file_path: 本地文件路径
-        oss_path: OSS目标路径
         filename: 文件名，如果为None则使用file_path的文件名
-        process_key: 处理键
-        device_id: 设备ID
+        driver_name: 驱动名称，用于构造scene
+        exp_type: 实验类型，用于构造scene
+        max_retries: 最大重试次数
+        client: HTTPClient实例，如果不提供则使用默认的http_client
 
     Returns:
-        是否成功上传
+        Dict: {
+            "success": bool,  # 是否上传成功
+            "original_path": str,  # 原始文件路径
+            "oss_path": str  # OSS路径（成功时）或空字符串（失败时）
+        }
     """
-    max_retries = OSSUploadConfig.max_retries
+    file_path = Path(file_path)
+    if filename is None:
+        filename = os.path.basename(file_path)
+
+    if not os.path.exists(file_path):
+        logger.error(f"[OSS] 文件不存在: {file_path}")
+        return {"success": False, "original_path": file_path, "oss_path": ""}
+
     retry_count = 0
+    oss_path = ""
 
     while retry_count < max_retries:
         try:
-            # 步骤1：初始化上传
-            init_success, init_data = _init_upload(
-                file_path=file_path,
-                oss_path=oss_path,
-                filename=filename,
-                process_key=process_key,
-                device_id=device_id
+            # 步骤1：获取预签名URL
+            token_success, token_data = _get_oss_token(
+                filename=filename, driver_name=driver_name, exp_type=exp_type, client=client
             )
 
-            if not init_success:
-                print(f"初始化上传失败，重试 {retry_count + 1}/{max_retries}")
+            if not token_success:
+                logger.warning(f"[OSS] 获取预签名URL失败，重试 {retry_count + 1}/{max_retries}")
                 retry_count += 1
-                time.sleep(1)  # 等待1秒后重试
+                time.sleep(1)
                 continue
 
-            # 获取UUID和上传URL
-            uuid = init_data.get("uuid")
-            upload_url = init_data.get("upload_url")
+            # 获取预签名URL和OSS路径
+            upload_url = token_data.get("url")
+            oss_path = token_data.get("path", "")
 
-            if not uuid or not upload_url:
-                print(f"初始化上传返回数据不完整，重试 {retry_count + 1}/{max_retries}")
+            if not upload_url:
+                logger.warning(f"[OSS] 无法获取上传URL，API未返回url字段")
                 retry_count += 1
                 time.sleep(1)
                 continue
@@ -163,69 +160,82 @@ def oss_upload(file_path: str, oss_path: str, filename: Optional[str] = None,
             # 步骤2：PUT上传文件
             put_success = _put_upload(file_path, upload_url)
             if not put_success:
-                print(f"PUT上传失败，重试 {retry_count + 1}/{max_retries}")
-                retry_count += 1
-                time.sleep(1)
-                continue
-
-            # 步骤3：完成上传
-            complete_success = _complete_upload(uuid)
-            if not complete_success:
-                print(f"完成上传失败，重试 {retry_count + 1}/{max_retries}")
+                logger.warning(f"[OSS] PUT上传失败，重试 {retry_count + 1}/{max_retries}")
                 retry_count += 1
                 time.sleep(1)
                 continue
 
             # 所有步骤都成功
-            print(f"文件 {file_path} 上传成功")
-            return True
+            logger.info(f"[OSS] 文件 {file_path} 上传成功")
+            return {"success": True, "original_path": file_path, "oss_path": oss_path}
 
         except Exception as e:
-            print(f"上传过程异常: {str(e)}，重试 {retry_count + 1}/{max_retries}")
+            logger.error(f"[OSS] 上传过程异常: {str(e)}，重试 {retry_count + 1}/{max_retries}")
             retry_count += 1
             time.sleep(1)
 
-    print(f"文件 {file_path} 上传失败，已达到最大重试次数 {max_retries}")
-    return False
+    logger.error(f"[OSS] 文件 {file_path} 上传失败，已达到最大重试次数 {max_retries}")
+    return {"success": False, "original_path": file_path, "oss_path": oss_path}
 
 
 if __name__ == "__main__":
-    # python -m unilabos.app.oss_upload -f /path/to/your/file.txt
+    # python -m unilabos.app.oss_upload -f /path/to/your/file.txt --driver HPLC --type test
+    # python -m unilabos.app.oss_upload -f /path/to/your/file.txt --driver HPLC --type test \
+    #        --ak xxx --sk yyy --remote-addr http://xxx/api/v1
     # 命令行参数解析
-    parser = argparse.ArgumentParser(description='文件上传测试工具')
-    parser.add_argument('--file', '-f', type=str, required=True, help='要上传的本地文件路径')
-    parser.add_argument('--path', '-p', type=str, default='/HPLC1/Any', help='OSS目标路径')
-    parser.add_argument('--device', '-d', type=str, default='test-device', help='设备ID')
-    parser.add_argument('--process', '-k', type=str, default='HPLC-txt-result', help='处理键')
+    parser = argparse.ArgumentParser(description="文件上传测试工具")
+    parser.add_argument("--file", "-f", type=str, required=True, help="要上传的本地文件路径")
+    parser.add_argument("--driver", "-d", type=str, default="default", help="驱动名称")
+    parser.add_argument("--type", "-t", type=str, default="default", help="实验类型")
+    parser.add_argument("--ak", type=str, help="Access Key，如果提供则覆盖配置")
+    parser.add_argument("--sk", type=str, help="Secret Key，如果提供则覆盖配置")
+    parser.add_argument("--remote-addr", type=str, help="远程服务器地址（包含/api/v1），如果提供则覆盖配置")
 
     args = parser.parse_args()
 
     # 检查文件是否存在
     if not os.path.exists(args.file):
-        print(f"错误：文件 {args.file} 不存在")
+        logger.error(f"错误：文件 {args.file} 不存在")
         exit(1)
 
-    print("=" * 50)
-    print(f"开始上传文件: {args.file}")
-    print(f"目标路径: {args.path}")
-    print(f"设备ID: {args.device}")
-    print(f"处理键: {args.process}")
-    print("=" * 50)
+    # 如果提供了ak/sk/remote_addr，创建临时HTTPClient
+    temp_client = None
+    if args.ak and args.sk:
+        import base64
+
+        auth = base64.b64encode(f"{args.ak}:{args.sk}".encode("utf-8")).decode("utf-8")
+        remote_addr = args.remote_addr if args.remote_addr else http_client.remote_addr
+        temp_client = HTTPClient(remote_addr=remote_addr, auth=auth)
+        logger.info(f"[配置] 使用自定义配置: remote_addr={remote_addr}")
+    elif args.remote_addr:
+        temp_client = HTTPClient(remote_addr=args.remote_addr, auth=http_client.auth)
+        logger.info(f"[配置] 使用自定义remote_addr: {args.remote_addr}")
+    else:
+        logger.info(f"[配置] 使用默认配置: remote_addr={http_client.remote_addr}")
+
+    logger.info("=" * 50)
+    logger.info(f"开始上传文件: {args.file}")
+    logger.info(f"驱动名称: {args.driver}")
+    logger.info(f"实验类型: {args.type}")
+    logger.info(f"Scene: {args.driver}-{args.type}")
+    logger.info("=" * 50)
 
     # 执行上传
-    success = oss_upload(
+    result = oss_upload(
         file_path=args.file,
-        oss_path=args.path,
         filename=None,  # 使用默认文件名
-        process_key=args.process,
-        device_id=args.device
+        driver_name=args.driver,
+        exp_type=args.type,
+        client=temp_client,
     )
 
     # 输出结果
-    if success:
-        print("\n√ 文件上传成功！")
+    if result["success"]:
+        logger.info(f"\n√ 文件上传成功！")
+        logger.info(f"原始路径: {result['original_path']}")
+        logger.info(f"OSS路径: {result['oss_path']}")
         exit(0)
     else:
-        print("\n× 文件上传失败！")
+        logger.error(f"\n× 文件上传失败！")
+        logger.error(f"原始路径: {result['original_path']}")
         exit(1)
-

unilabos/app/web/api.py

@@ -9,13 +9,22 @@ import asyncio
 
 import yaml
 
-from unilabos.app.web.controler import devices, job_add, job_info
+from unilabos.app.web.controller import (
+    devices,
+    job_add,
+    job_info,
+    get_online_devices,
+    get_device_actions,
+    get_action_schema,
+    get_all_available_actions,
+)
 from unilabos.app.model import (
     Resp,
     RespCode,
     JobStatusResp,
     JobAddResp,
     JobAddReq,
+    JobData,
 )
 from unilabos.app.web.utils.host_utils import get_host_node_info
 from unilabos.registry.registry import lab_registry
@@ -1234,6 +1243,65 @@ def get_devices():
     return Resp(data=dict(data))
 
 
+@api.get("/online-devices", summary="Online devices list", response_model=Resp)
+def api_get_online_devices():
+    """获取在线设备列表
+
+    返回当前在线的设备列表，包含设备ID、命名空间、机器名等信息
+    """
+    isok, data = get_online_devices()
+    if not isok:
+        return Resp(code=RespCode.ErrorHostNotInit, message=data.get("error", "Unknown error"))
+
+    return Resp(data=data)
+
+
+@api.get("/devices/{device_id}/actions", summary="Device actions list", response_model=Resp)
+def api_get_device_actions(device_id: str):
+    """获取设备可用的动作列表
+
+    Args:
+        device_id: 设备ID
+
+    返回指定设备的所有可用动作，包含动作名称、类型、是否繁忙等信息
+    """
+    isok, data = get_device_actions(device_id)
+    if not isok:
+        return Resp(code=RespCode.ErrorInvalidReq, message=data.get("error", "Unknown error"))
+
+    return Resp(data=data)
+
+
+@api.get("/devices/{device_id}/actions/{action_name}/schema", summary="Action schema", response_model=Resp)
+def api_get_action_schema(device_id: str, action_name: str):
+    """获取动作的Schema详情
+
+    Args:
+        device_id: 设备ID
+        action_name: 动作名称
+
+    返回动作的参数Schema、默认值、类型等详细信息
+    """
+    isok, data = get_action_schema(device_id, action_name)
+    if not isok:
+        return Resp(code=RespCode.ErrorInvalidReq, message=data.get("error", "Unknown error"))
+
+    return Resp(data=data)
+
+
+@api.get("/actions", summary="All available actions", response_model=Resp)
+def api_get_all_actions():
+    """获取所有设备的可用动作
+
+    返回所有已注册设备的动作列表，包含设备信息和各动作的状态
+    """
+    isok, data = get_all_available_actions()
+    if not isok:
+        return Resp(code=RespCode.ErrorHostNotInit, message=data.get("error", "Unknown error"))
+
+    return Resp(data=data)
+
+
 @api.get("/job/{id}/status", summary="Job status", response_model=JobStatusResp)
 def job_status(id: str):
     """获取任务状态"""
@@ -1244,11 +1312,22 @@ def job_status(id: str):
 @api.post("/job/add", summary="Create job", response_model=JobAddResp)
 def post_job_add(req: JobAddReq):
     """创建任务"""
-    device_id = req.device_id
-    if not req.data:
-        return Resp(code=RespCode.ErrorInvalidReq, message="Invalid request data")
+    # 检查必要参数：device_id 和 action
+    if not req.device_id:
+        return JobAddResp(
+            data=JobData(jobId="", status=6),
+            code=RespCode.ErrorInvalidReq,
+            message="device_id is required",
+        )
+
+    action_name = req.data.get("action", req.action) if req.data else req.action
+    if not action_name:
+        return JobAddResp(
+            data=JobData(jobId="", status=6),
+            code=RespCode.ErrorInvalidReq,
+            message="action is required",
+        )
 
-    req.device_id = device_id
     data = job_add(req)
     return JobAddResp(data=data)
 

unilabos/app/web/client.py

@@ -76,7 +76,8 @@ class HTTPClient:
             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))
+            payload = {"nodes": [x for xs in resources.dump() for x in xs], "mount_uuid": mount_uuid}
+            f.write(json.dumps(payload, indent=4))
         # 从序列化数据中提取所有节点的UUID（保存旧UUID）
         old_uuids = {n.res_content.uuid: n for n in resources.all_nodes}
         if not self.initialized or first_add:
@@ -331,6 +332,67 @@ class HTTPClient:
                 logger.error(f"响应内容: {response.text}")
         return None
 
+    def workflow_import(
+        self,
+        name: str,
+        workflow_uuid: str,
+        workflow_name: str,
+        nodes: List[Dict[str, Any]],
+        edges: List[Dict[str, Any]],
+        tags: Optional[List[str]] = None,
+        published: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        导入工作流到服务器
+
+        Args:
+            name: 工作流名称（顶层）
+            workflow_uuid: 工作流UUID
+            workflow_name: 工作流名称（data内部）
+            nodes: 工作流节点列表
+            edges: 工作流边列表
+            tags: 工作流标签列表，默认为空列表
+            published: 是否发布工作流，默认为False
+
+        Returns:
+            Dict: API响应数据，包含 code 和 data (uuid, name)
+        """
+        # target_lab_uuid 暂时使用默认值，后续由后端根据 ak/sk 获取
+        payload = {
+            "target_lab_uuid": "28c38bb0-63f6-4352-b0d8-b5b8eb1766d5",
+            "name": name,
+            "data": {
+                "workflow_uuid": workflow_uuid,
+                "workflow_name": workflow_name,
+                "nodes": nodes,
+                "edges": edges,
+                "tags": tags if tags is not None else [],
+                "published": published,
+            },
+        }
+        # 保存请求到文件
+        with open(os.path.join(BasicConfig.working_dir, "req_workflow_upload.json"), "w", encoding="utf-8") as f:
+            f.write(json.dumps(payload, indent=4, ensure_ascii=False))
+
+        response = requests.post(
+            f"{self.remote_addr}/lab/workflow/owner/import",
+            json=payload,
+            headers={"Authorization": f"Lab {self.auth}"},
+            timeout=60,
+        )
+        # 保存响应到文件
+        with open(os.path.join(BasicConfig.working_dir, "res_workflow_upload.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:
+                logger.error(f"导入工作流失败: {response.text}")
+            return res
+        else:
+            logger.error(f"导入工作流失败: {response.status_code}, {response.text}")
+            return {"code": response.status_code, "message": response.text}
+
 
 # 创建默认客户端实例
 http_client = HTTPClient()

unilabos/app/web/controler.py

@@ -1,45 +0,0 @@
-
-import json
-import traceback
-import uuid
-from unilabos.app.model import JobAddReq, JobData
-from unilabos.ros.nodes.presets.host_node import HostNode
-from unilabos.utils.type_check import serialize_result_info
-
-
-def get_resources() -> tuple:
-    if HostNode.get_instance() is None:
-        return False, "Host node not initialized"
-
-    return True, HostNode.get_instance().resources_config
-
-def devices() -> tuple:
-    if HostNode.get_instance() is None:
-        return False, "Host node not initialized"
-    
-    return True, HostNode.get_instance().devices_config
-
-def job_info(id: str):
-    get_goal_status = HostNode.get_instance().get_goal_status(id)
-    return JobData(jobId=id, status=get_goal_status)
-
-def job_add(req: JobAddReq) -> JobData:
-    if req.job_id is None:
-        req.job_id = str(uuid.uuid4())
-    action_name = req.data["action"]
-    action_type = req.data.get("action_type", "LocalUnknown")
-    action_args = req.data.get("action_kwargs", None)  # 兼容老版本，后续删除
-    if action_args is None:
-        action_args = req.data.get("action_args")
-    else:
-        if "command" in action_args:
-            action_args = action_args["command"]
-    # print(f"job_add:{req.device_id} {action_name} {action_kwargs}")
-    try:
-        HostNode.get_instance().send_goal(req.device_id, action_type=action_type, action_name=action_name, action_kwargs=action_args, goal_uuid=req.job_id, server_info=req.server_info)
-    except Exception as e:
-        for bridge in HostNode.get_instance().bridges:
-            traceback.print_exc()
-            if hasattr(bridge, "publish_job_status"):
-                bridge.publish_job_status({}, req.job_id, "failed", serialize_result_info(traceback.format_exc(), False, {}))
-    return JobData(jobId=req.job_id)

unilabos/app/web/controller.py

@@ -0,0 +1,587 @@
+"""
+Web API Controller
+
+提供Web API的控制器函数，处理设备、任务和动作相关的业务逻辑
+"""
+
+import threading
+import time
+import traceback
+import uuid
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, Tuple
+
+from unilabos.app.model import JobAddReq, JobData
+from unilabos.ros.nodes.presets.host_node import HostNode
+from unilabos.utils import logger
+
+
+@dataclass
+class JobResult:
+    """任务结果数据"""
+
+    job_id: str
+    status: int  # 4:SUCCEEDED, 5:CANCELED, 6:ABORTED
+    result: Dict[str, Any] = field(default_factory=dict)
+    feedback: Dict[str, Any] = field(default_factory=dict)
+    timestamp: float = field(default_factory=time.time)
+
+
+class JobResultStore:
+    """任务结果存储（单例）"""
+
+    _instance: Optional["JobResultStore"] = None
+    _lock = threading.Lock()
+
+    def __init__(self):
+        if not hasattr(self, "_initialized"):
+            self._results: Dict[str, JobResult] = {}
+            self._results_lock = threading.RLock()
+            self._initialized = True
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def store_result(
+        self, job_id: str, status: int, result: Optional[Dict[str, Any]], feedback: Optional[Dict[str, Any]] = None
+    ):
+        """存储任务结果"""
+        with self._results_lock:
+            self._results[job_id] = JobResult(
+                job_id=job_id,
+                status=status,
+                result=result or {},
+                feedback=feedback or {},
+                timestamp=time.time(),
+            )
+            logger.debug(f"[JobResultStore] Stored result for job {job_id[:8]}, status={status}")
+
+    def get_and_remove(self, job_id: str) -> Optional[JobResult]:
+        """获取并删除任务结果"""
+        with self._results_lock:
+            result = self._results.pop(job_id, None)
+            if result:
+                logger.debug(f"[JobResultStore] Retrieved and removed result for job {job_id[:8]}")
+            return result
+
+    def get_result(self, job_id: str) -> Optional[JobResult]:
+        """仅获取任务结果（不删除）"""
+        with self._results_lock:
+            return self._results.get(job_id)
+
+    def cleanup_old_results(self, max_age_seconds: float = 3600):
+        """清理过期的结果"""
+        current_time = time.time()
+        with self._results_lock:
+            expired_jobs = [
+                job_id for job_id, result in self._results.items() if current_time - result.timestamp > max_age_seconds
+            ]
+            for job_id in expired_jobs:
+                del self._results[job_id]
+                logger.debug(f"[JobResultStore] Cleaned up expired result for job {job_id[:8]}")
+
+
+# 全局结果存储实例
+job_result_store = JobResultStore()
+
+
+def store_job_result(
+    job_id: str, status: str, result: Optional[Dict[str, Any]], feedback: Optional[Dict[str, Any]] = None
+):
+    """存储任务结果（供外部调用）
+
+    Args:
+        job_id: 任务ID
+        status: 状态字符串 ("success", "failed", "cancelled")
+        result: 结果数据
+        feedback: 反馈数据
+    """
+    # 转换状态字符串为整数
+    status_map = {
+        "success": 4,  # SUCCEEDED
+        "failed": 6,  # ABORTED
+        "cancelled": 5,  # CANCELED
+        "running": 2,  # EXECUTING
+    }
+    status_int = status_map.get(status, 0)
+
+    # 只存储最终状态
+    if status_int in (4, 5, 6):
+        job_result_store.store_result(job_id, status_int, result, feedback)
+
+
+def get_resources() -> Tuple[bool, Any]:
+    """获取资源配置
+
+    Returns:
+        Tuple[bool, Any]: (是否成功, 资源配置或错误信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, "Host node not initialized"
+
+    return True, host_node.resources_config
+
+
+def devices() -> Tuple[bool, Any]:
+    """获取设备配置
+
+    Returns:
+        Tuple[bool, Any]: (是否成功, 设备配置或错误信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, "Host node not initialized"
+
+    return True, host_node.devices_config
+
+
+def job_info(job_id: str, remove_after_read: bool = True) -> JobData:
+    """获取任务信息
+
+    Args:
+        job_id: 任务ID
+        remove_after_read: 是否在读取后删除结果（默认True）
+
+    Returns:
+        JobData: 任务数据
+    """
+    # 首先检查结果存储中是否有已完成的结果
+    if remove_after_read:
+        stored_result = job_result_store.get_and_remove(job_id)
+    else:
+        stored_result = job_result_store.get_result(job_id)
+
+    if stored_result:
+        # 有存储的结果，直接返回
+        return JobData(
+            jobId=job_id,
+            status=stored_result.status,
+            result=stored_result.result,
+        )
+
+    # 没有存储的结果，从 HostNode 获取当前状态
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return JobData(jobId=job_id, status=0)
+
+    get_goal_status = host_node.get_goal_status(job_id)
+    return JobData(jobId=job_id, status=get_goal_status)
+
+
+def check_device_action_busy(device_id: str, action_name: str) -> Tuple[bool, Optional[str]]:
+    """检查设备动作是否正在执行（被占用）
+
+    Args:
+        device_id: 设备ID
+        action_name: 动作名称
+
+    Returns:
+        Tuple[bool, Optional[str]]: (是否繁忙, 当前执行的job_id或None)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, None
+
+    device_action_key = f"/devices/{device_id}/{action_name}"
+
+    # 检查 _device_action_status 中是否有正在执行的任务
+    if device_action_key in host_node._device_action_status:
+        status = host_node._device_action_status[device_action_key]
+        if status.job_ids:
+            # 返回第一个正在执行的job_id
+            current_job_id = next(iter(status.job_ids.keys()), None)
+            return True, current_job_id
+
+    return False, None
+
+
+def _get_action_type(device_id: str, action_name: str) -> Optional[str]:
+    """从注册表自动获取动作类型
+
+    Args:
+        device_id: 设备ID
+        action_name: 动作名称
+
+    Returns:
+        动作类型字符串，未找到返回None
+    """
+    try:
+        from unilabos.ros.nodes.base_device_node import registered_devices
+
+        # 方法1: 从运行时注册设备获取
+        if device_id in registered_devices:
+            device_info = registered_devices[device_id]
+            base_node = device_info.get("base_node_instance")
+            if base_node and hasattr(base_node, "_action_value_mappings"):
+                action_mappings = base_node._action_value_mappings
+                # 尝试直接匹配或 auto- 前缀匹配
+                for key in [action_name, f"auto-{action_name}"]:
+                    if key in action_mappings:
+                        action_type = action_mappings[key].get("type")
+                        if action_type:
+                            # 转换为字符串格式
+                            if hasattr(action_type, "__module__") and hasattr(action_type, "__name__"):
+                                return f"{action_type.__module__}.{action_type.__name__}"
+                            return str(action_type)
+
+        # 方法2: 从lab_registry获取
+        from unilabos.registry.registry import lab_registry
+
+        host_node = HostNode.get_instance(0)
+        if host_node and lab_registry:
+            devices_config = host_node.devices_config
+            device_class = None
+
+            for tree in devices_config.trees:
+                node = tree.root_node
+                if node.res_content.id == device_id:
+                    device_class = node.res_content.klass
+                    break
+
+            if device_class and device_class in lab_registry.device_type_registry:
+                device_type_info = lab_registry.device_type_registry[device_class]
+                class_info = device_type_info.get("class", {})
+                action_mappings = class_info.get("action_value_mappings", {})
+
+                for key in [action_name, f"auto-{action_name}"]:
+                    if key in action_mappings:
+                        action_type = action_mappings[key].get("type")
+                        if action_type:
+                            if hasattr(action_type, "__module__") and hasattr(action_type, "__name__"):
+                                return f"{action_type.__module__}.{action_type.__name__}"
+                            return str(action_type)
+
+    except Exception as e:
+        logger.warning(f"[Controller] Failed to get action type for {device_id}/{action_name}: {str(e)}")
+
+    return None
+
+
+def job_add(req: JobAddReq) -> JobData:
+    """添加任务（检查设备是否繁忙，繁忙则返回失败）
+
+    Args:
+        req: 任务添加请求
+
+    Returns:
+        JobData: 任务数据（包含状态）
+    """
+    # 服务端自动生成 job_id 和 task_id
+    job_id = str(uuid.uuid4())
+    task_id = str(uuid.uuid4())
+
+    # 服务端自动生成 server_info
+    server_info = {"send_timestamp": time.time()}
+
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        logger.error(f"[Controller] Host node not initialized for job: {job_id[:8]}")
+        return JobData(jobId=job_id, status=6)  # 6 = ABORTED
+
+    # 解析动作信息
+    action_name = req.data.get("action", req.action) if req.data else req.action
+    action_args = req.data.get("action_kwargs") or req.data.get("action_args") if req.data else req.action_args
+
+    if action_args is None:
+        action_args = req.action_args or {}
+    elif isinstance(action_args, dict) and "command" in action_args:
+        action_args = action_args["command"]
+
+    # 自动获取 action_type
+    action_type = _get_action_type(req.device_id, action_name)
+    if action_type is None:
+        logger.error(f"[Controller] Action type not found for {req.device_id}/{action_name}")
+        return JobData(jobId=job_id, status=6)  # ABORTED
+
+    # 检查设备动作是否繁忙
+    is_busy, current_job_id = check_device_action_busy(req.device_id, action_name)
+
+    if is_busy:
+        logger.warning(
+            f"[Controller] Device action busy: {req.device_id}/{action_name}, "
+            f"current job: {current_job_id[:8] if current_job_id else 'unknown'}"
+        )
+        # 返回失败状态，status=6 表示 ABORTED
+        return JobData(jobId=job_id, status=6)
+
+    # 设备空闲，提交任务执行
+    try:
+        from unilabos.app.ws_client import QueueItem
+
+        device_action_key = f"/devices/{req.device_id}/{action_name}"
+        queue_item = QueueItem(
+            task_type="job_call_back_status",
+            device_id=req.device_id,
+            action_name=action_name,
+            task_id=task_id,
+            job_id=job_id,
+            device_action_key=device_action_key,
+        )
+
+        host_node.send_goal(
+            queue_item,
+            action_type=action_type,
+            action_kwargs=action_args,
+            server_info=server_info,
+        )
+
+        logger.info(f"[Controller] Job submitted: {job_id[:8]} -> {req.device_id}/{action_name}")
+        # 返回已接受状态，status=1 表示 ACCEPTED
+        return JobData(jobId=job_id, status=1)
+
+    except ValueError as e:
+        # ActionClient not found 等错误
+        logger.error(f"[Controller] Action not available: {str(e)}")
+        return JobData(jobId=job_id, status=6)  # ABORTED
+
+    except Exception as e:
+        logger.error(f"[Controller] Error submitting job: {str(e)}")
+        traceback.print_exc()
+        return JobData(jobId=job_id, status=6)  # ABORTED
+
+
+def get_online_devices() -> Tuple[bool, Dict[str, Any]]:
+    """获取在线设备列表
+
+    Returns:
+        Tuple[bool, Dict]: (是否成功, 在线设备信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, {"error": "Host node not initialized"}
+
+    try:
+        from unilabos.ros.nodes.base_device_node import registered_devices
+
+        online_devices = {}
+        for device_key in host_node._online_devices:
+            # device_key 格式: "namespace/device_id"
+            parts = device_key.split("/")
+            if len(parts) >= 2:
+                device_id = parts[-1]
+            else:
+                device_id = device_key
+
+            # 获取设备详细信息
+            device_info = registered_devices.get(device_id, {})
+            machine_name = host_node.device_machine_names.get(device_id, "未知")
+
+            online_devices[device_id] = {
+                "device_key": device_key,
+                "namespace": host_node.devices_names.get(device_id, ""),
+                "machine_name": machine_name,
+                "uuid": device_info.get("uuid", "") if device_info else "",
+                "node_name": device_info.get("node_name", "") if device_info else "",
+            }
+
+        return True, {
+            "online_devices": online_devices,
+            "total_count": len(online_devices),
+            "timestamp": time.time(),
+        }
+
+    except Exception as e:
+        logger.error(f"[Controller] Error getting online devices: {str(e)}")
+        traceback.print_exc()
+        return False, {"error": str(e)}
+
+
+def get_device_actions(device_id: str) -> Tuple[bool, Dict[str, Any]]:
+    """获取设备可用的动作列表
+
+    Args:
+        device_id: 设备ID
+
+    Returns:
+        Tuple[bool, Dict]: (是否成功, 动作列表信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, {"error": "Host node not initialized"}
+
+    try:
+        from unilabos.ros.nodes.base_device_node import registered_devices
+        from unilabos.app.web.utils.action_utils import get_action_info
+
+        # 检查设备是否已注册
+        if device_id not in registered_devices:
+            return False, {"error": f"Device not found: {device_id}"}
+
+        device_info = registered_devices[device_id]
+        actions = device_info.get("actions", {})
+
+        actions_list = {}
+        for action_name, action_server in actions.items():
+            try:
+                action_info = get_action_info(action_server, action_name)
+                # 检查动作是否繁忙
+                is_busy, current_job = check_device_action_busy(device_id, action_name)
+                actions_list[action_name] = {
+                    **action_info,
+                    "is_busy": is_busy,
+                    "current_job_id": current_job[:8] if current_job else None,
+                }
+            except Exception as e:
+                logger.warning(f"[Controller] Error getting action info for {action_name}: {str(e)}")
+                actions_list[action_name] = {
+                    "type_name": "unknown",
+                    "action_path": f"/devices/{device_id}/{action_name}",
+                    "is_busy": False,
+                    "error": str(e),
+                }
+
+        return True, {
+            "device_id": device_id,
+            "actions": actions_list,
+            "action_count": len(actions_list),
+        }
+
+    except Exception as e:
+        logger.error(f"[Controller] Error getting device actions: {str(e)}")
+        traceback.print_exc()
+        return False, {"error": str(e)}
+
+
+def get_action_schema(device_id: str, action_name: str) -> Tuple[bool, Dict[str, Any]]:
+    """获取动作的Schema详情
+
+    Args:
+        device_id: 设备ID
+        action_name: 动作名称
+
+    Returns:
+        Tuple[bool, Dict]: (是否成功, Schema信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, {"error": "Host node not initialized"}
+
+    try:
+        from unilabos.registry.registry import lab_registry
+        from unilabos.ros.nodes.base_device_node import registered_devices
+
+        result = {
+            "device_id": device_id,
+            "action_name": action_name,
+            "schema": None,
+            "goal_default": None,
+            "action_type": None,
+            "is_busy": False,
+        }
+
+        # 检查动作是否繁忙
+        is_busy, current_job = check_device_action_busy(device_id, action_name)
+        result["is_busy"] = is_busy
+        result["current_job_id"] = current_job[:8] if current_job else None
+
+        # 方法1: 从 registered_devices 获取运行时信息
+        if device_id in registered_devices:
+            device_info = registered_devices[device_id]
+            base_node = device_info.get("base_node_instance")
+
+            if base_node and hasattr(base_node, "_action_value_mappings"):
+                action_mappings = base_node._action_value_mappings
+                if action_name in action_mappings:
+                    mapping = action_mappings[action_name]
+                    result["schema"] = mapping.get("schema")
+                    result["goal_default"] = mapping.get("goal_default")
+                    result["action_type"] = str(mapping.get("type", ""))
+
+        # 方法2: 从 lab_registry 获取注册表信息（如果运行时没有）
+        if result["schema"] is None and lab_registry:
+            # 尝试查找设备类型
+            devices_config = host_node.devices_config
+            device_class = None
+
+            # 从配置中获取设备类型
+            for tree in devices_config.trees:
+                node = tree.root_node
+                if node.res_content.id == device_id:
+                    device_class = node.res_content.klass
+                    break
+
+            if device_class and device_class in lab_registry.device_type_registry:
+                device_type_info = lab_registry.device_type_registry[device_class]
+                class_info = device_type_info.get("class", {})
+                action_mappings = class_info.get("action_value_mappings", {})
+
+                # 尝试直接匹配或 auto- 前缀匹配
+                for key in [action_name, f"auto-{action_name}"]:
+                    if key in action_mappings:
+                        mapping = action_mappings[key]
+                        result["schema"] = mapping.get("schema")
+                        result["goal_default"] = mapping.get("goal_default")
+                        result["action_type"] = str(mapping.get("type", ""))
+                        result["handles"] = mapping.get("handles", {})
+                        result["placeholder_keys"] = mapping.get("placeholder_keys", {})
+                        break
+
+        if result["schema"] is None:
+            return False, {"error": f"Action schema not found: {device_id}/{action_name}"}
+
+        return True, result
+
+    except Exception as e:
+        logger.error(f"[Controller] Error getting action schema: {str(e)}")
+        traceback.print_exc()
+        return False, {"error": str(e)}
+
+
+def get_all_available_actions() -> Tuple[bool, Dict[str, Any]]:
+    """获取所有设备的可用动作
+
+    Returns:
+        Tuple[bool, Dict]: (是否成功, 所有设备的动作信息)
+    """
+    host_node = HostNode.get_instance(0)
+    if host_node is None:
+        return False, {"error": "Host node not initialized"}
+
+    try:
+        from unilabos.ros.nodes.base_device_node import registered_devices
+        from unilabos.app.web.utils.action_utils import get_action_info
+
+        all_actions = {}
+        total_action_count = 0
+
+        for device_id, device_info in registered_devices.items():
+            actions = device_info.get("actions", {})
+            device_actions = {}
+
+            for action_name, action_server in actions.items():
+                try:
+                    action_info = get_action_info(action_server, action_name)
+                    is_busy, current_job = check_device_action_busy(device_id, action_name)
+                    device_actions[action_name] = {
+                        "type_name": action_info.get("type_name", ""),
+                        "action_path": action_info.get("action_path", ""),
+                        "is_busy": is_busy,
+                        "current_job_id": current_job[:8] if current_job else None,
+                    }
+                    total_action_count += 1
+                except Exception as e:
+                    logger.warning(f"[Controller] Error processing action {device_id}/{action_name}: {str(e)}")
+
+            if device_actions:
+                all_actions[device_id] = {
+                    "actions": device_actions,
+                    "action_count": len(device_actions),
+                    "machine_name": host_node.device_machine_names.get(device_id, "未知"),
+                }
+
+        return True, {
+            "devices": all_actions,
+            "device_count": len(all_actions),
+            "total_action_count": total_action_count,
+            "timestamp": time.time(),
+        }
+
+    except Exception as e:
+        logger.error(f"[Controller] Error getting all available actions: {str(e)}")
+        traceback.print_exc()
+        return False, {"error": str(e)}

unilabos/app/ws_client.py

@@ -359,6 +359,7 @@ class MessageProcessor:
         self.device_manager = device_manager
         self.queue_processor = None  # 延迟设置
         self.websocket_client = None  # 延迟设置
+        self.session_id = ""
 
         # WebSocket连接
         self.websocket = None
@@ -388,7 +389,7 @@ class MessageProcessor:
         self.is_running = True
         self.thread = threading.Thread(target=self._run, daemon=True, name="MessageProcessor")
         self.thread.start()
-        logger.info("[MessageProcessor] Started")
+        logger.trace("[MessageProcessor] Started")
 
     def stop(self) -> None:
         """停止消息处理线程"""
@@ -420,21 +421,24 @@ 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,
                     ssl=ssl_context,
                     ping_interval=WSConfig.ping_interval,
                     ping_timeout=10,
-                    additional_headers={"Authorization": f"Lab {BasicConfig.auth_secret()}"},
+                    additional_headers={
+                        "Authorization": f"Lab {BasicConfig.auth_secret()}",
+                        "EdgeSession": f"{self.session_id}",
+                    },
                     logger=ws_logger,
                 ) as websocket:
                     self.websocket = websocket
                     self.connected = True
                     self.reconnect_count = 0
 
-                    logger.info(f"[MessageProcessor] Connected to {self.websocket_url}")
+                    logger.trace(f"[MessageProcessor] Connected to {self.websocket_url}")
 
                     # 启动发送协程
                     send_task = asyncio.create_task(self._send_handler())
@@ -499,7 +503,7 @@ class MessageProcessor:
 
     async def _send_handler(self):
         """处理发送队列中的消息"""
-        logger.debug("[MessageProcessor] Send handler started")
+        logger.trace("[MessageProcessor] Send handler started")
 
         try:
             while self.connected and self.websocket:
@@ -572,6 +576,9 @@ class MessageProcessor:
                 await self._handle_resource_tree_update(message_data, "update")
             elif message_type == "remove_material":
                 await self._handle_resource_tree_update(message_data, "remove")
+            elif message_type == "session_id":
+                self.session_id = message_data.get("session_id")
+                logger.info(f"[MessageProcessor] Session ID: {self.session_id}")
             else:
                 logger.debug(f"[MessageProcessor] Unknown message type: {message_type}")
 
@@ -932,7 +939,7 @@ class QueueProcessor:
         # 事件通知机制
         self.queue_update_event = threading.Event()
 
-        logger.info("[QueueProcessor] Initialized")
+        logger.trace("[QueueProcessor] Initialized")
 
     def set_websocket_client(self, websocket_client: "WebSocketClient"):
         """设置WebSocket客户端引用"""
@@ -947,7 +954,7 @@ class QueueProcessor:
         self.is_running = True
         self.thread = threading.Thread(target=self._run, daemon=True, name="QueueProcessor")
         self.thread.start()
-        logger.info("[QueueProcessor] Started")
+        logger.trace("[QueueProcessor] Started")
 
     def stop(self) -> None:
         """停止队列处理线程"""
@@ -958,7 +965,7 @@ class QueueProcessor:
 
     def _run(self):
         """运行队列处理主循环"""
-        logger.debug("[QueueProcessor] Queue processor started")
+        logger.trace("[QueueProcessor] Queue processor started")
 
         while self.is_running:
             try:
@@ -1168,7 +1175,6 @@ class WebSocketClient(BaseCommunicationClient):
         else:
             url = f"{scheme}://{parsed.netloc}/api/v1/ws/schedule"
 
-        logger.debug(f"[WebSocketClient] URL: {url}")
         return url
 
     def start(self) -> None:
@@ -1181,13 +1187,11 @@ class WebSocketClient(BaseCommunicationClient):
             logger.error("[WebSocketClient] WebSocket URL not configured")
             return
 
-        logger.info(f"[WebSocketClient] Starting connection to {self.websocket_url}")
-
         # 启动两个核心线程
         self.message_processor.start()
         self.queue_processor.start()
 
-        logger.info("[WebSocketClient] All threads started")
+        logger.trace("[WebSocketClient] All threads started")
 
     def stop(self) -> None:
         """停止WebSocket客户端"""
@@ -1196,6 +1200,18 @@ class WebSocketClient(BaseCommunicationClient):
 
         logger.info("[WebSocketClient] Stopping connection")
 
+        # 发送 normal_exit 消息
+        if self.is_connected():
+            try:
+                session_id = self.message_processor.session_id
+                message = {"action": "normal_exit", "data": {"session_id": session_id}}
+                self.message_processor.send_message(message)
+                logger.info(f"[WebSocketClient] Sent normal_exit message with session_id: {session_id}")
+                # 给一点时间让消息发送出去
+                time.sleep(1)
+            except Exception as e:
+                logger.warning(f"[WebSocketClient] Failed to send normal_exit message: {str(e)}")
+
         # 停止两个核心线程
         self.message_processor.stop()
         self.queue_processor.stop()
@@ -1224,7 +1240,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
@@ -1295,3 +1311,19 @@ class WebSocketClient(BaseCommunicationClient):
             logger.info(f"[WebSocketClient] Job {job_log} cancelled successfully")
         else:
             logger.warning(f"[WebSocketClient] Failed to cancel job {job_log}")
+
+    def publish_host_ready(self) -> None:
+        """发布host_node ready信号"""
+        if self.is_disabled or not self.is_connected():
+            logger.debug("[WebSocketClient] Not connected, cannot publish host ready signal")
+            return
+
+        message = {
+            "action": "host_node_ready",
+            "data": {
+                "status": "ready",
+                "timestamp": time.time(),
+            },
+        }
+        self.message_processor.send_message(message)
+        logger.info("[WebSocketClient] Host node ready signal published")

unilabos/config/config.py

@@ -21,7 +21,8 @@ class BasicConfig:
     startup_json_path = None  # 填写绝对路径
     disable_browser = False  # 禁止浏览器自动打开
     port = 8002  # 本地HTTP服务
-    log_level: Literal['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = "DEBUG"  # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
+    # 'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
+    log_level: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
 
     @classmethod
     def auth_secret(cls):
@@ -39,18 +40,9 @@ class WSConfig:
     ping_interval = 30  # ping间隔（秒）
 
 
-# OSS上传配置
-class OSSUploadConfig:
-    api_host = ""
-    authorization = ""
-    init_endpoint = ""
-    complete_endpoint = ""
-    max_retries = 3
-
-
 # HTTP配置
 class HTTPConfig:
-    remote_addr = "http://127.0.0.1:48197/api/v1"
+    remote_addr = "https://uni-lab.bohrium.com/api/v1"
 
 
 # ROS配置
@@ -74,13 +66,14 @@ def _update_config_from_module(module):
                     if not attr.startswith("_"):
                         setattr(obj, attr, getattr(getattr(module, name), attr))
 
+
 def _update_config_from_env():
     prefix = "UNILABOS_"
     for env_key, env_value in os.environ.items():
         if not env_key.startswith(prefix):
             continue
         try:
-            key_path = env_key[len(prefix):]  # Remove UNILAB_ prefix
+            key_path = env_key[len(prefix) :]  # Remove UNILAB_ prefix
             class_field = key_path.upper().split("_", 1)
             if len(class_field) != 2:
                 logger.warning(f"[ENV] 环境变量格式不正确：{env_key}")

unilabos/device_comms/modbus_plc/client.py

@@ -4,8 +4,7 @@ import traceback
 from typing import Any, Union, List, Dict, Callable, Optional, Tuple
 from pydantic import BaseModel
 
-from pymodbus.client import ModbusSerialClient, ModbusTcpClient
-from pymodbus.framer import FramerType
+from pymodbus.client.sync import ModbusSerialClient, ModbusTcpClient
 from typing import TypedDict
 
 from unilabos.device_comms.modbus_plc.modbus import DeviceType, HoldRegister, Coil, InputRegister, DiscreteInputs, DataType, WorderOrder
@@ -403,7 +402,7 @@ class TCPClient(BaseClient):
 class RTUClient(BaseClient):
     def __init__(self, port: str, baudrate: int, timeout: int):
         super().__init__()
-        self._set_client(ModbusSerialClient(framer=FramerType.RTU, port=port, baudrate=baudrate, timeout=timeout))
+        self._set_client(ModbusSerialClient(method='rtu', port=port, baudrate=baudrate, timeout=timeout))
         self._connect()
 
 if __name__ == '__main__':

unilabos/device_comms/modbus_plc/modbus.py

@@ -1,12 +1,26 @@
 # coding=utf-8
 from enum import Enum
 from abc import ABC, abstractmethod
+from typing import Tuple, Union, Optional, TYPE_CHECKING
+from pymodbus.payload import BinaryPayloadDecoder, BinaryPayloadBuilder
+from pymodbus.constants import Endian
 
-from pymodbus.client import ModbusBaseSyncClient
-from pymodbus.client.mixin import ModbusClientMixin 
-from typing import Tuple, Union, Optional
+if TYPE_CHECKING:
+    from pymodbus.client.sync import ModbusSerialClient, ModbusTcpClient
+
+# Define DataType enum for pymodbus 2.5.3 compatibility
+class DataType(Enum):
+    INT16 = "int16"
+    UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
+    INT64 = "int64"
+    UINT64 = "uint64"
+    FLOAT32 = "float32"
+    FLOAT64 = "float64"
+    STRING = "string"
+    BOOL = "bool"
 
-DataType = ModbusClientMixin.DATATYPE
 
 class WorderOrder(Enum):
     BIG = "big"
@@ -19,8 +33,96 @@ class DeviceType(Enum):
     INPUT_REGISTER = 'input_register'
 
 
+def _convert_from_registers(registers, data_type: DataType, word_order: str = 'big'):
+    """Convert registers to a value using BinaryPayloadDecoder.
+    
+    Args:
+        registers: List of register values
+        data_type: DataType enum specifying the target data type
+        word_order: 'big' or 'little' endian
+        
+    Returns:
+        Converted value
+    """
+    # Determine byte and word order based on word_order parameter
+    if word_order == 'little':
+        byte_order = Endian.Little
+        word_order_enum = Endian.Little
+    else:
+        byte_order = Endian.Big
+        word_order_enum = Endian.Big
+    
+    decoder = BinaryPayloadDecoder.fromRegisters(registers, byteorder=byte_order, wordorder=word_order_enum)
+    
+    if data_type == DataType.INT16:
+        return decoder.decode_16bit_int()
+    elif data_type == DataType.UINT16:
+        return decoder.decode_16bit_uint()
+    elif data_type == DataType.INT32:
+        return decoder.decode_32bit_int()
+    elif data_type == DataType.UINT32:
+        return decoder.decode_32bit_uint()
+    elif data_type == DataType.INT64:
+        return decoder.decode_64bit_int()
+    elif data_type == DataType.UINT64:
+        return decoder.decode_64bit_uint()
+    elif data_type == DataType.FLOAT32:
+        return decoder.decode_32bit_float()
+    elif data_type == DataType.FLOAT64:
+        return decoder.decode_64bit_float()
+    elif data_type == DataType.STRING:
+        return decoder.decode_string(len(registers) * 2)
+    else:
+        raise ValueError(f"Unsupported data type: {data_type}")
+
+
+def _convert_to_registers(value, data_type: DataType, word_order: str = 'little'):
+    """Convert a value to registers using BinaryPayloadBuilder.
+    
+    Args:
+        value: Value to convert
+        data_type: DataType enum specifying the source data type
+        word_order: 'big' or 'little' endian
+        
+    Returns:
+        List of register values
+    """
+    # Determine byte and word order based on word_order parameter
+    if word_order == 'little':
+        byte_order = Endian.Little
+        word_order_enum = Endian.Little
+    else:
+        byte_order = Endian.Big
+        word_order_enum = Endian.Big
+    
+    builder = BinaryPayloadBuilder(byteorder=byte_order, wordorder=word_order_enum)
+    
+    if data_type == DataType.INT16:
+        builder.add_16bit_int(value)
+    elif data_type == DataType.UINT16:
+        builder.add_16bit_uint(value)
+    elif data_type == DataType.INT32:
+        builder.add_32bit_int(value)
+    elif data_type == DataType.UINT32:
+        builder.add_32bit_uint(value)
+    elif data_type == DataType.INT64:
+        builder.add_64bit_int(value)
+    elif data_type == DataType.UINT64:
+        builder.add_64bit_uint(value)
+    elif data_type == DataType.FLOAT32:
+        builder.add_32bit_float(value)
+    elif data_type == DataType.FLOAT64:
+        builder.add_64bit_float(value)
+    elif data_type == DataType.STRING:
+        builder.add_string(value)
+    else:
+        raise ValueError(f"Unsupported data type: {data_type}")
+    
+    return builder.to_registers()
+
+
 class Base(ABC):
-    def __init__(self, client: ModbusBaseSyncClient, name: str, address: int, typ: DeviceType, data_type: DataType):
+    def __init__(self, client, name: str, address: int, typ: DeviceType, data_type):
         self._address: int = address
         self._client = client
         self._name = name
@@ -58,7 +160,11 @@ class Coil(Base):
                 count = value,
                 slave = slave)
 
-        return resp.bits, resp.isError()
+        # 检查是否读取出错
+        if resp.isError():
+            return [], True
+        
+        return resp.bits, False
 
     def write(self,value: Union[int, float, bool, str, list[bool], list[int], list[float]], data_type: Optional[DataType ]= None, word_order: WorderOrder = WorderOrder.LITTLE, slave = 1) -> bool:
         if isinstance(value, list):
@@ -91,8 +197,18 @@ class DiscreteInputs(Base):
                 count = value,
                 slave = slave)
 
+        # 检查是否读取出错
+        if resp.isError():
+            # 根据数据类型返回默认值
+            if data_type in [DataType.FLOAT32, DataType.FLOAT64]:
+                return 0.0, True
+            elif data_type == DataType.STRING:
+                return "", True
+            else:
+                return 0, True
+        
         # noinspection PyTypeChecker
-        return self._client.convert_from_registers(resp.registers, data_type, word_order=word_order.value), resp.isError()
+        return _convert_from_registers(resp.registers, data_type, word_order=word_order.value), False
 
     def write(self,value: Union[int, float, bool, str, list[bool], list[int], list[float]], data_type: Optional[DataType ]= None, word_order: WorderOrder = WorderOrder.LITTLE, slave = 1) -> bool:
         raise ValueError('discrete inputs only support read')
@@ -112,8 +228,19 @@ class HoldRegister(Base):
                 address = self.address,
                 count = value,
                 slave = slave)
+        
+        # 检查是否读取出错
+        if resp.isError():
+            # 根据数据类型返回默认值
+            if data_type in [DataType.FLOAT32, DataType.FLOAT64]:
+                return 0.0, True
+            elif data_type == DataType.STRING:
+                return "", True
+            else:
+                return 0, True
+        
         # noinspection PyTypeChecker
-        return self._client.convert_from_registers(resp.registers, data_type, word_order=word_order.value), resp.isError()
+        return _convert_from_registers(resp.registers, data_type, word_order=word_order.value), False
 
 
     def write(self,value: Union[int, float, bool, str, list[bool], list[int], list[float]], data_type: Optional[DataType ]= None, word_order: WorderOrder = WorderOrder.LITTLE, slave = 1) -> bool:
@@ -132,7 +259,7 @@ class HoldRegister(Base):
             return self._client.write_register(self.address, value, slave= slave).isError()
         else:
             # noinspection PyTypeChecker
-            encoder_resp = self._client.convert_to_registers(value, data_type=data_type, word_order=word_order.value)
+            encoder_resp = _convert_to_registers(value, data_type=data_type, word_order=word_order.value)
             return self._client.write_registers(self.address, encoder_resp, slave=slave).isError()
 
 
@@ -153,8 +280,19 @@ class InputRegister(Base):
                 address = self.address,
                 count = value,
                 slave = slave)
+        
+        # 检查是否读取出错
+        if resp.isError():
+            # 根据数据类型返回默认值
+            if data_type in [DataType.FLOAT32, DataType.FLOAT64]:
+                return 0.0, True
+            elif data_type == DataType.STRING:
+                return "", True
+            else:
+                return 0, True
+        
         # noinspection PyTypeChecker
-        return self._client.convert_from_registers(resp.registers, data_type, word_order=word_order.value), resp.isError()
+        return _convert_from_registers(resp.registers, data_type, word_order=word_order.value), False
 
     def write(self,value: Union[int, float, bool, str, list[bool], list[int], list[float]], data_type: Optional[DataType ]= None, word_order: WorderOrder = WorderOrder.LITTLE, slave = 1) -> bool:
         raise ValueError('input register only support read')

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/hplc/AgilentHPLC.py

@@ -405,9 +405,19 @@ class RunningResultChecker(DriverChecker):
                 for i in range(self.driver._finished, temp):
                     sample_id = self.driver._get_resource_sample_id(self.driver._wf_name, i)  # 从0开始计数
                     pdf, txt = self.driver.get_data_file(i + 1)
-                    device_id = self.driver.device_id if hasattr(self.driver, "device_id") else "default"
-                    oss_upload(pdf, f"hplc/{sample_id}/{os.path.basename(pdf)}", process_key="example", device_id=device_id)
-                    oss_upload(txt, f"hplc/{sample_id}/{os.path.basename(txt)}", process_key="HPLC-txt-result", device_id=device_id)
+                    # 使用新的OSS上传接口，传入driver_name和exp_type
+                    pdf_result = oss_upload(pdf, filename=os.path.basename(pdf), driver_name="HPLC", exp_type="analysis")
+                    txt_result = oss_upload(txt, filename=os.path.basename(txt), driver_name="HPLC", exp_type="result")
+                    
+                    if pdf_result["success"]:
+                        print(f"PDF上传成功: {pdf_result['oss_path']}")
+                    else:
+                        print(f"PDF上传失败: {pdf_result['original_path']}")
+                    
+                    if txt_result["success"]:
+                        print(f"TXT上传成功: {txt_result['oss_path']}")
+                    else:
+                        print(f"TXT上传失败: {txt_result['original_path']}")
                     # self.driver.extract_data_from_txt()
         except Exception as ex:
             self.driver._finished = 0
@@ -456,8 +466,12 @@ if __name__ == "__main__":
     }
     sample_id = obj._get_resource_sample_id("test", 0)
     pdf, txt = obj.get_data_file("1", after_time=datetime(2024, 11, 6, 19, 3, 6))
-    oss_upload(pdf, f"hplc/{sample_id}/{os.path.basename(pdf)}", process_key="example")
-    oss_upload(txt, f"hplc/{sample_id}/{os.path.basename(txt)}", process_key="HPLC-txt-result")
+    # 使用新的OSS上传接口，传入driver_name和exp_type
+    pdf_result = oss_upload(pdf, filename=os.path.basename(pdf), driver_name="HPLC", exp_type="analysis")
+    txt_result = oss_upload(txt, filename=os.path.basename(txt), driver_name="HPLC", exp_type="result")
+    
+    print(f"PDF上传结果: {pdf_result}")
+    print(f"TXT上传结果: {txt_result}")
     # driver = HPLCDriver()
     # for i in range(10000):
     #     print({k: v for k, v in driver._device_status.items() if isinstance(v, str)})

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -147,6 +147,9 @@ class LiquidHandlerMiddleware(LiquidHandler):
         offsets: Optional[List[Coordinate]] = None,
         **backend_kwargs,
     ):
+        # 如果 use_channels 为 None，使用默认值（所有通道）
+        if use_channels is None:
+            use_channels = list(range(self.channel_num))
         if not offsets or (isinstance(offsets, list) and len(offsets) != len(use_channels)):
             offsets = [Coordinate.zero()] * len(use_channels)
         if self._simulator:
@@ -759,7 +762,7 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                             blow_out_air_volume=current_dis_blow_out_air_volume,
                             spread=spread,
                         )
-                        if delays is not None:
+                        if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
                         await self.touch_tip(current_targets)
                         await self.discard_tips()        
@@ -833,17 +836,19 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                             spread=spread,
                         )
 
-                        if delays is not None:
+                        if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
-                        await self.mix(
-                            targets=[targets[_]],
-                            mix_time=mix_time,
-                            mix_vol=mix_vol,
-                            offsets=offsets if offsets else None,
-                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
-                            mix_rate=mix_rate if mix_rate else None,
-                        )
-                        if delays is not None:
+                        # 只有在 mix_time 有效时才调用 mix
+                        if mix_time is not None and mix_time > 0:
+                            await self.mix(
+                                targets=[targets[_]],
+                                mix_time=mix_time,
+                                mix_vol=mix_vol,
+                                offsets=offsets if offsets else None,
+                                height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                                mix_rate=mix_rate if mix_rate else None,
+                            )
+                        if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
                         await self.touch_tip(targets[_])
                         await self.discard_tips()
@@ -893,18 +898,20 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                             blow_out_air_volume=current_dis_blow_out_air_volume,
                             spread=spread,
                         )
-                        if delays is not None:
+                        if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
 
-                        await self.mix(
-                            targets=current_targets,
-                            mix_time=mix_time,
-                            mix_vol=mix_vol,
-                            offsets=offsets if offsets else None,
-                            height_to_bottom=mix_liquid_height if mix_liquid_height else None,
-                            mix_rate=mix_rate if mix_rate else None,
-                        )
-                        if delays is not None:
+                        # 只有在 mix_time 有效时才调用 mix
+                        if mix_time is not None and mix_time > 0:
+                            await self.mix(
+                                targets=current_targets,
+                                mix_time=mix_time,
+                                mix_vol=mix_vol,
+                                offsets=offsets if offsets else None,
+                                height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                                mix_rate=mix_rate if mix_rate else None,
+                            )
+                        if delays is not None and len(delays) > 1:
                             await self.custom_delay(seconds=delays[1])
                         await self.touch_tip(current_targets)
                         await self.discard_tips()
@@ -942,60 +949,158 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
         delays: Optional[List[int]] = None,
         none_keys: List[str] = [],
     ):
-        """Transfer liquid from each *source* well/plate to the corresponding *target*.
+        """Transfer liquid with automatic mode detection.
+
+        Supports three transfer modes:
+        1. One-to-many (1 source -> N targets): Distribute from one source to multiple targets
+        2. One-to-one (N sources -> N targets): Standard transfer, each source to corresponding target
+        3. Many-to-one (N sources -> 1 target): Combine multiple sources into one target
 
         Parameters
         ----------
         asp_vols, dis_vols
-            Single volume (µL) or list matching the number of transfers.
+            Single volume (µL) or list. Automatically expanded based on transfer mode.
         sources, targets
-            Same‑length sequences of containers (wells or plates). In 96‑well mode
-            each must contain exactly one plate.
+            Containers (wells or plates). Length determines transfer mode:
+            - len(sources) == 1, len(targets) > 1: One-to-many mode
+            - len(sources) == len(targets): One-to-one mode
+            - len(sources) > 1, len(targets) == 1: Many-to-one mode
         tip_racks
             One or more TipRacks providing fresh tips.
         is_96_well
             Set *True* to use the 96‑channel head.
         """
-
-
+        
+        # 确保 use_channels 有默认值
+        if use_channels is None:
+            use_channels = [0] if self.channel_num >= 1 else list(range(self.channel_num))
+        
         if is_96_well:
             pass  # This mode is not verified.
         else:
-            if len(asp_vols) != len(targets):
-                raise ValueError(f"Length of `asp_vols` {len(asp_vols)} must match `targets` {len(targets)}.")
+            # 转换体积参数为列表
+            if isinstance(asp_vols, (int, float)):
+                asp_vols = [float(asp_vols)]
+            else:
+                asp_vols = [float(v) for v in asp_vols]
+            
+            if isinstance(dis_vols, (int, float)):
+                dis_vols = [float(dis_vols)]
+            else:
+                dis_vols = [float(v) for v in dis_vols]
 
-            # 首先应该对任务分组，然后每次1个/8个进行操作处理
-            if len(use_channels) == 1:
-                for _ in range(len(targets)):
-                    tip = []
-                    for ___ in range(len(use_channels)):
-                        tip.extend(next(self.current_tip))
-                    await self.pick_up_tips(tip)
+        # 统一混合次数为标量，防止数组/列表与 int 比较时报错
+        if mix_times is not None and not isinstance(mix_times, (int, float)):
+            try:
+                mix_times = mix_times[0] if len(mix_times) > 0 else None
+            except Exception:
+                try:
+                    mix_times = next(iter(mix_times))
+                except Exception:
+                    pass
+        if mix_times is not None:
+            mix_times = int(mix_times)
+            
+            # 识别传输模式
+            num_sources = len(sources)
+            num_targets = len(targets)
+            
+            if num_sources == 1 and num_targets > 1:
+                # 模式1: 一对多 (1 source -> N targets)
+                await self._transfer_one_to_many(
+                    sources[0], targets, tip_racks, use_channels,
+                    asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
+                    offsets, touch_tip, liquid_height, blow_out_air_volume,
+                    spread, mix_stage, mix_times, mix_vol, mix_rate,
+                    mix_liquid_height, delays
+                )
+            elif num_sources > 1 and num_targets == 1:
+                # 模式2: 多对一 (N sources -> 1 target)
+                await self._transfer_many_to_one(
+                    sources, targets[0], tip_racks, use_channels,
+                    asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
+                    offsets, touch_tip, liquid_height, blow_out_air_volume,
+                    spread, mix_stage, mix_times, mix_vol, mix_rate,
+                    mix_liquid_height, delays
+                )
+            elif num_sources == num_targets:
+                # 模式3: 一对一 (N sources -> N targets) - 原有逻辑
+                await self._transfer_one_to_one(
+                    sources, targets, tip_racks, use_channels,
+                    asp_vols, dis_vols, asp_flow_rates, dis_flow_rates,
+                    offsets, touch_tip, liquid_height, blow_out_air_volume,
+                    spread, mix_stage, mix_times, mix_vol, mix_rate,
+                    mix_liquid_height, delays
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported transfer mode: {num_sources} sources -> {num_targets} targets. "
+                    "Supported modes: 1->N, N->1, or N->N."
+                )
 
-                    await self.aspirate(
-                        resources=[sources[_]],
-                        vols=[asp_vols[_]],
-                        use_channels=use_channels,
-                        flow_rates=[asp_flow_rates[0]] if asp_flow_rates else None,
-                        offsets=[offsets[0]] if offsets else None,
-                        liquid_height=[liquid_height[0]] if liquid_height else None,
-                        blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume else None,
-                        spread=spread,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[0])
-                    await self.dispense(
-                        resources=[targets[_]],
-                        vols=[dis_vols[_]],
-                        use_channels=use_channels,
-                        flow_rates=[dis_flow_rates[1]] if dis_flow_rates else None,
-                        offsets=[offsets[1]] if offsets else None,
-                        blow_out_air_volume=[blow_out_air_volume[1]] if blow_out_air_volume else None,
-                        liquid_height=[liquid_height[1]] if liquid_height else None,
-                        spread=spread,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
+    async def _transfer_one_to_one(
+        self,
+        sources: Sequence[Container],
+        targets: Sequence[Container],
+        tip_racks: Sequence[TipRack],
+        use_channels: List[int],
+        asp_vols: List[float],
+        dis_vols: List[float],
+        asp_flow_rates: Optional[List[Optional[float]]],
+        dis_flow_rates: Optional[List[Optional[float]]],
+        offsets: Optional[List[Coordinate]],
+        touch_tip: bool,
+        liquid_height: Optional[List[Optional[float]]],
+        blow_out_air_volume: Optional[List[Optional[float]]],
+        spread: Literal["wide", "tight", "custom"],
+        mix_stage: Optional[Literal["none", "before", "after", "both"]],
+        mix_times: Optional[int],
+        mix_vol: Optional[int],
+        mix_rate: Optional[int],
+        mix_liquid_height: Optional[float],
+        delays: Optional[List[int]],
+    ):
+        """一对一传输模式：N sources -> N targets"""
+        # 验证参数长度
+        if len(asp_vols) != len(targets):
+            raise ValueError(f"Length of `asp_vols` {len(asp_vols)} must match `targets` {len(targets)}.")
+        if len(dis_vols) != len(targets):
+            raise ValueError(f"Length of `dis_vols` {len(dis_vols)} must match `targets` {len(targets)}.")
+        if len(sources) != len(targets):
+            raise ValueError(f"Length of `sources` {len(sources)} must match `targets` {len(targets)}.")
+
+        if len(use_channels) == 1:
+            for _ in range(len(targets)):
+                tip = []
+                for ___ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+
+                await self.aspirate(
+                    resources=[sources[_]],
+                    vols=[asp_vols[_]],
+                    use_channels=use_channels,
+                    flow_rates=[asp_flow_rates[_]] if asp_flow_rates and len(asp_flow_rates) > _ else None,
+                    offsets=[offsets[_]] if offsets and len(offsets) > _ else None,
+                    liquid_height=[liquid_height[_]] if liquid_height and len(liquid_height) > _ else None,
+                    blow_out_air_volume=[blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None,
+                    spread=spread,
+                )
+                if delays is not None:
+                    await self.custom_delay(seconds=delays[0])
+                await self.dispense(
+                    resources=[targets[_]],
+                    vols=[dis_vols[_]],
+                    use_channels=use_channels,
+                    flow_rates=[dis_flow_rates[_]] if dis_flow_rates and len(dis_flow_rates) > _ else None,
+                    offsets=[offsets[_]] if offsets and len(offsets) > _ else None,
+                    blow_out_air_volume=[blow_out_air_volume[_]] if blow_out_air_volume and len(blow_out_air_volume) > _ else None,
+                    liquid_height=[liquid_height[_]] if liquid_height and len(liquid_height) > _ else None,
+                    spread=spread,
+                )
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
                     await self.mix(
                         targets=[targets[_]],
                         mix_time=mix_times,
@@ -1004,63 +1109,60 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
                     )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
-                    await self.touch_tip(targets[_])
-                    await self.discard_tips()
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                await self.touch_tip(targets[_])
+                await self.discard_tips(use_channels=use_channels)
 
-            elif len(use_channels) == 8:
-                # 对于8个的情况，需要判断此时任务是不是能被8通道移液站来成功处理
-                if len(targets) % 8 != 0:
-                    raise ValueError(f"Length of `targets` {len(targets)} must be a multiple of 8 for 8-channel mode.")
+        elif len(use_channels) == 8:
+            if len(targets) % 8 != 0:
+                raise ValueError(f"Length of `targets` {len(targets)} must be a multiple of 8 for 8-channel mode.")
 
-                # 8个8个来取任务序列
+            for i in range(0, len(targets), 8):
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+                current_targets = targets[i:i + 8]
+                current_reagent_sources = sources[i:i + 8]
+                current_asp_vols = asp_vols[i:i + 8]
+                current_dis_vols = dis_vols[i:i + 8]
+                current_asp_flow_rates = asp_flow_rates[i:i + 8] if asp_flow_rates else None
+                current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
+                current_dis_offset = offsets[i:i + 8] if offsets else [None] * 8
+                current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                current_dis_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                current_dis_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else None
 
-                for i in range(0, len(targets), 8):
-                    # 取出8个任务
-                    tip = []
-                    for _ in range(len(use_channels)):
-                        tip.extend(next(self.current_tip))
-                    await self.pick_up_tips(tip)
-                    current_targets = targets[i:i + 8]
-                    current_reagent_sources = sources[i:i + 8]
-                    current_asp_vols = asp_vols[i:i + 8]
-                    current_dis_vols = dis_vols[i:i + 8]
-                    current_asp_flow_rates = asp_flow_rates[i:i + 8]
-                    current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
-                    current_dis_offset = offsets[-i*8-8:len(offsets)-i*8] if offsets else [None] * 8
-                    current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
-                    current_dis_liquid_height = liquid_height[-i*8-8:len(liquid_height)-i*8] if liquid_height else [None] * 8
-                    current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
-                    current_dis_blow_out_air_volume = blow_out_air_volume[-i*8-8:len(blow_out_air_volume)-i*8] if blow_out_air_volume else [None] * 8
-                    current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else [None] * 8
+                await self.aspirate(
+                    resources=current_reagent_sources,
+                    vols=current_asp_vols,
+                    use_channels=use_channels,
+                    flow_rates=current_asp_flow_rates,
+                    offsets=current_asp_offset,
+                    blow_out_air_volume=current_asp_blow_out_air_volume,
+                    liquid_height=current_asp_liquid_height,
+                    spread=spread,
+                )
 
-                    await self.aspirate(
-                        resources=current_reagent_sources,
-                        vols=current_asp_vols,
-                        use_channels=use_channels,
-                        flow_rates=current_asp_flow_rates,
-                        offsets=current_asp_offset,
-                        blow_out_air_volume=current_asp_blow_out_air_volume,
-                        liquid_height=current_asp_liquid_height,
-                        spread=spread,
-                    )
-
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[0])
-                    await self.dispense(
-                        resources=current_targets,
-                        vols=current_dis_vols,
-                        use_channels=use_channels,
-                        flow_rates=current_dis_flow_rates,
-                        offsets=current_dis_offset,
-                        blow_out_air_volume=current_dis_blow_out_air_volume,
-                        liquid_height=current_dis_liquid_height,
-                        spread=spread,
-                    )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
+                if delays is not None:
+                    await self.custom_delay(seconds=delays[0])
+                await self.dispense(
+                    resources=current_targets,
+                    vols=current_dis_vols,
+                    use_channels=use_channels,
+                    flow_rates=current_dis_flow_rates,
+                    offsets=current_dis_offset,
+                    blow_out_air_volume=current_dis_blow_out_air_volume,
+                    liquid_height=current_dis_liquid_height,
+                    spread=spread,
+                )
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
 
+                if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
                     await self.mix(
                         targets=current_targets,
                         mix_time=mix_times,
@@ -1069,10 +1171,363 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                         height_to_bottom=mix_liquid_height if mix_liquid_height else None,
                         mix_rate=mix_rate if mix_rate else None,
                     )
-                    if delays is not None:
-                        await self.custom_delay(seconds=delays[1])
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                await self.touch_tip(current_targets)
+                await self.discard_tips([0,1,2,3,4,5,6,7])
+
+    async def _transfer_one_to_many(
+        self,
+        source: Container,
+        targets: Sequence[Container],
+        tip_racks: Sequence[TipRack],
+        use_channels: List[int],
+        asp_vols: List[float],
+        dis_vols: List[float],
+        asp_flow_rates: Optional[List[Optional[float]]],
+        dis_flow_rates: Optional[List[Optional[float]]],
+        offsets: Optional[List[Coordinate]],
+        touch_tip: bool,
+        liquid_height: Optional[List[Optional[float]]],
+        blow_out_air_volume: Optional[List[Optional[float]]],
+        spread: Literal["wide", "tight", "custom"],
+        mix_stage: Optional[Literal["none", "before", "after", "both"]],
+        mix_times: Optional[int],
+        mix_vol: Optional[int],
+        mix_rate: Optional[int],
+        mix_liquid_height: Optional[float],
+        delays: Optional[List[int]],
+    ):
+        """一对多传输模式：1 source -> N targets"""
+        # 验证和扩展体积参数
+        if len(asp_vols) == 1:
+            # 如果只提供一个吸液体积，计算总吸液体积（所有分液体积之和）
+            total_asp_vol = sum(dis_vols)
+            asp_vol = asp_vols[0] if asp_vols[0] >= total_asp_vol else total_asp_vol
+        else:
+            raise ValueError("For one-to-many mode, `asp_vols` should be a single value or list with one element.")
+        
+        if len(dis_vols) != len(targets):
+            raise ValueError(f"Length of `dis_vols` {len(dis_vols)} must match `targets` {len(targets)}.")
+
+        if len(use_channels) == 1:
+            # 单通道模式：一次吸液，多次分液
+            tip = []
+            for _ in range(len(use_channels)):
+                tip.extend(next(self.current_tip))
+            await self.pick_up_tips(tip)
+
+            # 从源容器吸液（总体积）
+            await self.aspirate(
+                resources=[source],
+                vols=[asp_vol],
+                use_channels=use_channels,
+                flow_rates=[asp_flow_rates[0]] if asp_flow_rates and len(asp_flow_rates) > 0 else None,
+                offsets=[offsets[0]] if offsets and len(offsets) > 0 else None,
+                liquid_height=[liquid_height[0]] if liquid_height and len(liquid_height) > 0 else None,
+                blow_out_air_volume=[blow_out_air_volume[0]] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None,
+                spread=spread,
+            )
+            
+            if delays is not None:
+                await self.custom_delay(seconds=delays[0])
+            
+            # 分多次分液到不同的目标容器
+            for idx, target in enumerate(targets):
+                await self.dispense(
+                    resources=[target],
+                    vols=[dis_vols[idx]],
+                    use_channels=use_channels,
+                    flow_rates=[dis_flow_rates[idx]] if dis_flow_rates and len(dis_flow_rates) > idx else None,
+                    offsets=[offsets[idx]] if offsets and len(offsets) > idx else None,
+                    blow_out_air_volume=[blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None,
+                    liquid_height=[liquid_height[idx]] if liquid_height and len(liquid_height) > idx else None,
+                    spread=spread,
+                )
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+                    await self.mix(
+                        targets=[target],
+                        mix_time=mix_times,
+                        mix_vol=mix_vol,
+                        offsets=offsets[idx:idx+1] if offsets else None,
+                        height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                        mix_rate=mix_rate if mix_rate else None,
+                    )
+                if touch_tip:
+                    await self.touch_tip([target])
+            
+            await self.discard_tips(use_channels=use_channels)
+        
+        elif len(use_channels) == 8:
+            # 8通道模式：需要确保目标数量是8的倍数
+            if len(targets) % 8 != 0:
+                raise ValueError(f"For 8-channel mode, number of targets {len(targets)} must be a multiple of 8.")
+            
+            # 每次处理8个目标
+            for i in range(0, len(targets), 8):
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+                
+                current_targets = targets[i:i + 8]
+                current_dis_vols = dis_vols[i:i + 8]
+                
+                # 8个通道都从同一个源容器吸液，每个通道的吸液体积等于对应的分液体积
+                current_asp_flow_rates = asp_flow_rates[0:1] * 8 if asp_flow_rates and len(asp_flow_rates) > 0 else None
+                current_asp_offset = offsets[0:1] * 8 if offsets and len(offsets) > 0 else [None] * 8
+                current_asp_liquid_height = liquid_height[0:1] * 8 if liquid_height and len(liquid_height) > 0 else [None] * 8
+                current_asp_blow_out_air_volume = blow_out_air_volume[0:1] * 8 if blow_out_air_volume and len(blow_out_air_volume) > 0 else [None] * 8
+                
+                # 从源容器吸液（8个通道都从同一个源，但每个通道的吸液体积不同）
+                await self.aspirate(
+                    resources=[source] * 8,  # 8个通道都从同一个源
+                    vols=current_dis_vols,  # 每个通道的吸液体积等于对应的分液体积
+                    use_channels=use_channels,
+                    flow_rates=current_asp_flow_rates,
+                    offsets=current_asp_offset,
+                    liquid_height=current_asp_liquid_height,
+                    blow_out_air_volume=current_asp_blow_out_air_volume,
+                    spread=spread,
+                )
+                
+                if delays is not None:
+                    await self.custom_delay(seconds=delays[0])
+                
+                # 分液到8个目标
+                current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else None
+                current_dis_offset = offsets[i:i + 8] if offsets else [None] * 8
+                current_dis_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                current_dis_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                
+                await self.dispense(
+                    resources=current_targets,
+                    vols=current_dis_vols,
+                    use_channels=use_channels,
+                    flow_rates=current_dis_flow_rates,
+                    offsets=current_dis_offset,
+                    blow_out_air_volume=current_dis_blow_out_air_volume,
+                    liquid_height=current_dis_liquid_height,
+                    spread=spread,
+                )
+                
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                
+                if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+                    await self.mix(
+                        targets=current_targets,
+                        mix_time=mix_times,
+                        mix_vol=mix_vol,
+                        offsets=offsets if offsets else None,
+                        height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                        mix_rate=mix_rate if mix_rate else None,
+                    )
+                
+                if touch_tip:
                     await self.touch_tip(current_targets)
-                    await self.discard_tips([0,1,2,3,4,5,6,7])
+                
+                await self.discard_tips([0,1,2,3,4,5,6,7])
+
+    async def _transfer_many_to_one(
+        self,
+        sources: Sequence[Container],
+        target: Container,
+        tip_racks: Sequence[TipRack],
+        use_channels: List[int],
+        asp_vols: List[float],
+        dis_vols: List[float],
+        asp_flow_rates: Optional[List[Optional[float]]],
+        dis_flow_rates: Optional[List[Optional[float]]],
+        offsets: Optional[List[Coordinate]],
+        touch_tip: bool,
+        liquid_height: Optional[List[Optional[float]]],
+        blow_out_air_volume: Optional[List[Optional[float]]],
+        spread: Literal["wide", "tight", "custom"],
+        mix_stage: Optional[Literal["none", "before", "after", "both"]],
+        mix_times: Optional[int],
+        mix_vol: Optional[int],
+        mix_rate: Optional[int],
+        mix_liquid_height: Optional[float],
+        delays: Optional[List[int]],
+    ):
+        """多对一传输模式：N sources -> 1 target（汇总/混合）"""
+        # 验证和扩展体积参数
+        if len(asp_vols) != len(sources):
+            raise ValueError(f"Length of `asp_vols` {len(asp_vols)} must match `sources` {len(sources)}.")
+        
+        # 支持两种模式：
+        # 1. dis_vols 为单个值：所有源汇总，使用总吸液体积或指定分液体积
+        # 2. dis_vols 长度等于 asp_vols：每个源按不同比例分液（按比例混合）
+        if len(dis_vols) == 1:
+            # 模式1：使用单个分液体积
+            total_dis_vol = sum(asp_vols)
+            dis_vol = dis_vols[0] if dis_vols[0] >= total_dis_vol else total_dis_vol
+            use_proportional_mixing = False
+        elif len(dis_vols) == len(asp_vols):
+            # 模式2：按不同比例混合
+            use_proportional_mixing = True
+        else:
+            raise ValueError(
+                f"For many-to-one mode, `dis_vols` should be a single value or list with length {len(asp_vols)} "
+                f"(matching `asp_vols`). Got length {len(dis_vols)}."
+            )
+
+        if len(use_channels) == 1:
+            # 单通道模式：多次吸液，一次分液
+            # 先混合前（如果需要）
+            if mix_stage in ["before", "both"] and mix_times is not None and mix_times > 0:
+                # 注意：在吸液前混合源容器通常不常见，这里跳过
+                pass
+            
+            # 从每个源容器吸液并分液到目标容器
+            for idx, source in enumerate(sources):
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+
+                await self.aspirate(
+                    resources=[source],
+                    vols=[asp_vols[idx]],
+                    use_channels=use_channels,
+                    flow_rates=[asp_flow_rates[idx]] if asp_flow_rates and len(asp_flow_rates) > idx else None,
+                    offsets=[offsets[idx]] if offsets and len(offsets) > idx else None,
+                    liquid_height=[liquid_height[idx]] if liquid_height and len(liquid_height) > idx else None,
+                    blow_out_air_volume=[blow_out_air_volume[idx]] if blow_out_air_volume and len(blow_out_air_volume) > idx else None,
+                    spread=spread,
+                )
+                
+                if delays is not None:
+                    await self.custom_delay(seconds=delays[0])
+                
+                # 分液到目标容器
+                if use_proportional_mixing:
+                    # 按不同比例混合：使用对应的 dis_vols
+                    dis_vol = dis_vols[idx]
+                    dis_flow_rate = dis_flow_rates[idx] if dis_flow_rates and len(dis_flow_rates) > idx else None
+                    dis_offset = offsets[idx] if offsets and len(offsets) > idx else None
+                    dis_liquid_height = liquid_height[idx] if liquid_height and len(liquid_height) > idx else None
+                    dis_blow_out = blow_out_air_volume[idx] if blow_out_air_volume and len(blow_out_air_volume) > idx else None
+                else:
+                    # 标准模式：分液体积等于吸液体积
+                    dis_vol = asp_vols[idx]
+                    dis_flow_rate = dis_flow_rates[0] if dis_flow_rates and len(dis_flow_rates) > 0 else None
+                    dis_offset = offsets[0] if offsets and len(offsets) > 0 else None
+                    dis_liquid_height = liquid_height[0] if liquid_height and len(liquid_height) > 0 else None
+                    dis_blow_out = blow_out_air_volume[0] if blow_out_air_volume and len(blow_out_air_volume) > 0 else None
+                
+                await self.dispense(
+                    resources=[target],
+                    vols=[dis_vol],
+                    use_channels=use_channels,
+                    flow_rates=[dis_flow_rate] if dis_flow_rate is not None else None,
+                    offsets=[dis_offset] if dis_offset is not None else None,
+                    blow_out_air_volume=[dis_blow_out] if dis_blow_out is not None else None,
+                    liquid_height=[dis_liquid_height] if dis_liquid_height is not None else None,
+                    spread=spread,
+                )
+                
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                
+                await self.discard_tips(use_channels=use_channels)
+            
+            # 最后在目标容器中混合（如果需要）
+            if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+                await self.mix(
+                    targets=[target],
+                    mix_time=mix_times,
+                    mix_vol=mix_vol,
+                    offsets=offsets[0:1] if offsets else None,
+                    height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                    mix_rate=mix_rate if mix_rate else None,
+                )
+            
+            if touch_tip:
+                await self.touch_tip([target])
+        
+        elif len(use_channels) == 8:
+            # 8通道模式：需要确保源数量是8的倍数
+            if len(sources) % 8 != 0:
+                raise ValueError(f"For 8-channel mode, number of sources {len(sources)} must be a multiple of 8.")
+            
+            # 每次处理8个源
+            for i in range(0, len(sources), 8):
+                tip = []
+                for _ in range(len(use_channels)):
+                    tip.extend(next(self.current_tip))
+                await self.pick_up_tips(tip)
+                
+                current_sources = sources[i:i + 8]
+                current_asp_vols = asp_vols[i:i + 8]
+                current_asp_flow_rates = asp_flow_rates[i:i + 8] if asp_flow_rates else None
+                current_asp_offset = offsets[i:i + 8] if offsets else [None] * 8
+                current_asp_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                current_asp_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                
+                # 从8个源容器吸液
+                await self.aspirate(
+                    resources=current_sources,
+                    vols=current_asp_vols,
+                    use_channels=use_channels,
+                    flow_rates=current_asp_flow_rates,
+                    offsets=current_asp_offset,
+                    blow_out_air_volume=current_asp_blow_out_air_volume,
+                    liquid_height=current_asp_liquid_height,
+                    spread=spread,
+                )
+                
+                if delays is not None:
+                    await self.custom_delay(seconds=delays[0])
+                
+                # 分液到目标容器（每个通道分液到同一个目标）
+                if use_proportional_mixing:
+                    # 按比例混合：使用对应的 dis_vols
+                    current_dis_vols = dis_vols[i:i + 8]
+                    current_dis_flow_rates = dis_flow_rates[i:i + 8] if dis_flow_rates else None
+                    current_dis_offset = offsets[i:i + 8] if offsets else [None] * 8
+                    current_dis_liquid_height = liquid_height[i:i + 8] if liquid_height else [None] * 8
+                    current_dis_blow_out_air_volume = blow_out_air_volume[i:i + 8] if blow_out_air_volume else [None] * 8
+                else:
+                    # 标准模式：每个通道分液体积等于其吸液体积
+                    current_dis_vols = current_asp_vols
+                    current_dis_flow_rates = dis_flow_rates[0:1] * 8 if dis_flow_rates else None
+                    current_dis_offset = offsets[0:1] * 8 if offsets else [None] * 8
+                    current_dis_liquid_height = liquid_height[0:1] * 8 if liquid_height else [None] * 8
+                    current_dis_blow_out_air_volume = blow_out_air_volume[0:1] * 8 if blow_out_air_volume else [None] * 8
+                
+                await self.dispense(
+                    resources=[target] * 8,  # 8个通道都分到同一个目标
+                    vols=current_dis_vols,
+                    use_channels=use_channels,
+                    flow_rates=current_dis_flow_rates,
+                    offsets=current_dis_offset,
+                    blow_out_air_volume=current_dis_blow_out_air_volume,
+                    liquid_height=current_dis_liquid_height,
+                    spread=spread,
+                )
+                
+                if delays is not None and len(delays) > 1:
+                    await self.custom_delay(seconds=delays[1])
+                
+                await self.discard_tips([0,1,2,3,4,5,6,7])
+            
+            # 最后在目标容器中混合（如果需要）
+            if mix_stage in ["after", "both"] and mix_times is not None and mix_times > 0:
+                await self.mix(
+                    targets=[target],
+                    mix_time=mix_times,
+                    mix_vol=mix_vol,
+                    offsets=offsets[0:1] if offsets else None,
+                    height_to_bottom=mix_liquid_height if mix_liquid_height else None,
+                    mix_rate=mix_rate if mix_rate else None,
+                )
+            
+            if touch_tip:
+                await self.touch_tip([target])
 
     # except Exception as e:
     #     traceback.print_exc()

unilabos/devices/liquid_handling/prcxi/prcxi.py

@@ -5,6 +5,7 @@ import json
 import os
 import socket
 import time
+import uuid
 from typing import Any, List, Dict, Optional, Tuple, TypedDict, Union, Sequence, Iterator, Literal
 
 from pylabrobot.liquid_handling import (
@@ -856,7 +857,30 @@ class PRCXI9300Api:
 
     def _raw_request(self, payload: str) -> str:
         if self.debug:
-            return " "
+            # 调试/仿真模式下直接返回可解析的模拟 JSON，避免后续 json.loads 报错
+            try:
+                req = json.loads(payload)
+                method = req.get("MethodName")
+            except Exception:
+                method = None
+
+            data: Any = True
+            if method in {"AddSolution"}:
+                data = str(uuid.uuid4())
+            elif method in {"AddWorkTabletMatrix", "AddWorkTabletMatrix2"}:
+                data = {"Success": True, "Message": "debug mock"}
+            elif method in {"GetErrorCode"}:
+                data = ""
+            elif method in {"RemoveErrorCodet", "Reset", "Start", "LoadSolution", "Pause", "Resume", "Stop"}:
+                data = True
+            elif method in {"GetStepStateList", "GetStepStatus", "GetStepState"}:
+                data = []
+            elif method in {"GetLocation"}:
+                data = {"X": 0, "Y": 0, "Z": 0}
+            elif method in {"GetResetStatus"}:
+                data = False
+
+            return json.dumps({"Success": True, "Msg": "debug mock", "Data": data})
         with contextlib.closing(socket.socket()) as sock:
             sock.settimeout(self.timeout)
             sock.connect((self.host, self.port))

unilabos/devices/separator/chinwe.py

@@ -1,282 +1,649 @@
-import sys
-import threading
-import serial
-import serial.tools.list_ports
-import re
-import time
-from typing import Optional, List, Dict, Tuple
+# -*- coding: utf-8 -*-
+"""
+Contains drivers for:
+1. SyringePump: Runze Fluid SY-03B (ASCII)
+2. EmmMotor: Emm V5.0 Closed-loop Stepper (Modbus-RTU variant)
+3. XKCSensor: XKC Non-contact Level Sensor (Modbus-RTU)
+"""
 
-class ChinweDevice:
+import socket
+import serial
+import time
+import threading
+import struct
+import re
+import traceback
+import queue
+from typing import Optional, Dict, List, Any
+
+try:
+    from unilabos.device_comms.universal_driver import UniversalDriver
+except ImportError:
+    import logging
+    class UniversalDriver:
+        def __init__(self):
+            self.logger = logging.getLogger(self.__class__.__name__)
+
+        def execute_command_from_outer(self, command: str):
+            pass
+
+# ==============================================================================
+# 1. Transport Layer (通信层)
+# ==============================================================================
+
+class TransportManager:
     """
-    ChinWe设备控制类
-    提供串口通信、电机控制、传感器数据读取等功能
+    统一通信管理类。
+    自动识别 串口 (Serial) 或 网络 (TCP) 连接。
     """
-    
-    def __init__(self, port: str, baudrate: int = 115200, debug: bool = False):
-        """
-        初始化ChinWe设备
-        
-        Args:
-            port: 串口名称，如果为None则自动检测
-            baudrate: 波特率，默认115200
-        """
-        self.debug = debug
+    def __init__(self, port: str, baudrate: int = 9600, timeout: float = 3.0, logger=None):
         self.port = port
         self.baudrate = baudrate
-        self.serial_port: Optional[serial.Serial] = None
-        self._voltage: float = 0.0
-        self._ec_value: float = 0.0
-        self._ec_adc_value: int = 0
+        self.timeout = timeout
+        self.logger = logger
+        self.lock = threading.RLock() # 线程锁，确保多设备共用一个连接时不冲突
+
+        self.is_tcp = False
+        self.serial = None
+        self.socket = None
+
+        # 简单判断: 如果包含 ':' (如 192.168.1.1:8899) 或者看起来像 IP，则认为是 TCP
+        if ':' in self.port or (self.port.count('.') == 3 and not self.port.startswith('/')):
+            self.is_tcp = True
+            self._connect_tcp()
+        else:
+            self._connect_serial()
+
+    def _log(self, msg):
+        if self.logger:
+             pass
+            # self.logger.debug(f"[Transport] {msg}")
+
+    def _connect_tcp(self):
+        try:
+            if ':' in self.port:
+                host, p = self.port.split(':')
+                self.tcp_host = host
+                self.tcp_port = int(p)
+            else:
+                self.tcp_host = self.port
+                self.tcp_port = 8899 # 默认端口
+
+            # if self.logger: self.logger.info(f"Connecting TCP {self.tcp_host}:{self.tcp_port} ...")
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.settimeout(self.timeout)
+            self.socket.connect((self.tcp_host, self.tcp_port))
+        except Exception as e:
+            raise ConnectionError(f"TCP connection failed: {e}")
+
+    def _connect_serial(self):
+        try:
+            # if self.logger: self.logger.info(f"Opening Serial {self.port} (Baud: {self.baudrate}) ...")
+            self.serial = serial.Serial(
+                port=self.port,
+                baudrate=self.baudrate,
+                timeout=self.timeout
+            )
+        except Exception as e:
+            raise ConnectionError(f"Serial open failed: {e}")
+
+    def close(self):
+        """关闭连接"""
+        if self.is_tcp and self.socket:
+            try: self.socket.close()
+            except: pass
+        elif not self.is_tcp and self.serial and self.serial.is_open:
+            self.serial.close()
+
+    def clear_buffer(self):
+        """清空缓冲区 (Thread-safe)"""
+        with self.lock:
+            if self.is_tcp:
+                self.socket.setblocking(False)
+                try:
+                    while True:
+                        if not self.socket.recv(1024): break
+                except: pass
+                finally: self.socket.settimeout(self.timeout)
+            else:
+                self.serial.reset_input_buffer()
+
+    def write(self, data: bytes):
+        """发送原始字节"""
+        with self.lock:
+            if self.is_tcp:
+                self.socket.sendall(data)
+            else:
+                self.serial.write(data)
+
+    def read(self, size: int) -> bytes:
+        """读取指定长度字节"""
+        if self.is_tcp:
+            data = b''
+            start = time.time()
+            while len(data) < size:
+                if time.time() - start > self.timeout: break
+                try:
+                    chunk = self.socket.recv(size - len(data))
+                    if not chunk: break
+                    data += chunk
+                except socket.timeout: break
+            return data
+        else:
+            return self.serial.read(size)
+
+    def send_ascii_command(self, command: str) -> str:
+        """
+        发送 ASCII 字符串命令 (如注射泵指令)，读取直到 '\r'。
+        """
+        with self.lock:
+            data = command.encode('ascii') if isinstance(command, str) else command
+            self.clear_buffer()
+            self.write(data)
+
+            # Read until \r
+            if self.is_tcp:
+                resp = b''
+                start = time.time()
+                while True:
+                    if time.time() - start > self.timeout: break
+                    try:
+                        char = self.socket.recv(1)
+                        if not char: break
+                        resp += char
+                        if char == b'\r': break
+                    except: break
+                return resp.decode('ascii', errors='ignore').strip()
+            else:
+                return self.serial.read_until(b'\r').decode('ascii', errors='ignore').strip()
+
+# ==============================================================================
+# 2. Syringe Pump Driver (注射泵)
+# ==============================================================================
+
+class SyringePump:
+    """SY-03B 注射泵驱动 (ASCII协议)"""
+
+    CMD_INITIALIZE = "Z{speed},{drain_port},{output_port}R"
+    CMD_SWITCH_VALVE = "I{port}R"
+    CMD_ASPIRATE = "P{vol}R"
+    CMD_DISPENSE = "D{vol}R"
+    CMD_DISPENSE_ALL = "A0R"
+    CMD_STOP = "TR"
+    CMD_QUERY_STATUS = "Q"
+    CMD_QUERY_PLUNGER = "?0"
+
+    def __init__(self, device_id: int, transport: TransportManager):
+        if not 1 <= device_id <= 15:
+            pass # Allow all IDs for now
+        self.id = str(device_id)
+        self.transport = transport
+
+    def _send(self, template: str, **kwargs) -> str:
+        cmd = f"/{self.id}" + template.format(**kwargs) + "\r"
+        return self.transport.send_ascii_command(cmd)
+
+    def is_busy(self) -> bool:
+        """查询繁忙状态"""
+        resp = self._send(self.CMD_QUERY_STATUS)
+        # 响应如 /0` (Ready, 0x60) 或 /0@ (Busy, 0x40)
+        if len(resp) >= 3:
+            status_byte = ord(resp[2])
+            # Bit 5: 1=Ready, 0=Busy
+            return (status_byte & 0x20) == 0
+        return False
+
+    def wait_until_idle(self, timeout=30):
+        """阻塞等待直到空闲"""
+        start = time.time()
+        while time.time() - start < timeout:
+            if not self.is_busy(): return
+            time.sleep(0.5)
+        # raise TimeoutError(f"Pump {self.id} wait idle timeout")
+        pass
+
+    def initialize(self, drain_port=0, output_port=0, speed=10):
+        """初始化"""
+        self._send(self.CMD_INITIALIZE, speed=speed, drain_port=drain_port, output_port=output_port)
+
+    def switch_valve(self, port: int):
+        """切换阀门 (1-8)"""
+        self._send(self.CMD_SWITCH_VALVE, port=port)
+
+    def aspirate(self, steps: int):
+        """吸液 (相对步数)"""
+        self._send(self.CMD_ASPIRATE, vol=steps)
+
+    def dispense(self, steps: int):
+        """排液 (相对步数)"""
+        self._send(self.CMD_DISPENSE, vol=steps)
+
+    def stop(self):
+        """停止"""
+        self._send(self.CMD_STOP)
+
+    def get_position(self) -> int:
+        """获取柱塞位置 (步数)"""
+        resp = self._send(self.CMD_QUERY_PLUNGER)
+        m = re.search(r'\d+', resp)
+        return int(m.group()) if m else -1
+
+# ==============================================================================
+# 3. Stepper Motor Driver (步进电机)
+# ==============================================================================
+
+class EmmMotor:
+    """Emm V5.0 闭环步进电机驱动"""
+
+    def __init__(self, device_id: int, transport: TransportManager):
+        self.id = device_id
+        self.transport = transport
+
+    def _send(self, func_code: int, payload: list) -> bytes:
+        with self.transport.lock:
+            self.transport.clear_buffer()
+            # 格式: [ID] [Func] [Data...] [Check=0x6B]
+            body = [self.id, func_code] + payload
+            body.append(0x6B) # Checksum
+            self.transport.write(bytes(body))
+
+            # 根据指令不同，读取不同长度响应
+            read_len = 10 if func_code in [0x31, 0x32, 0x35, 0x24, 0x27] else 4
+            return self.transport.read(read_len)
+
+    def enable(self, on=True):
+        """使能 (True=锁轴, False=松轴)"""
+        state = 1 if on else 0
+        self._send(0xF3, [0xAB, state, 0])
+
+    def run_speed(self, speed_rpm: int, direction=0, acc=10):
+        """速度模式运行"""
+        sp = struct.pack('>H', int(speed_rpm))
+        self._send(0xF6, [direction, sp[0], sp[1], acc, 0])
+
+    def run_position(self, pulses: int, speed_rpm: int, direction=0, acc=10, absolute=False):
+        """位置模式运行"""
+        sp = struct.pack('>H', int(speed_rpm))
+        pl = struct.pack('>I', int(pulses))
+        is_abs = 1 if absolute else 0
+        self._send(0xFD, [direction, sp[0], sp[1], acc, pl[0], pl[1], pl[2], pl[3], is_abs, 0])
+
+    def stop(self):
+        """停止"""
+        self._send(0xFE, [0x98, 0])
+
+    def set_zero(self):
+        """清零位置"""
+        self._send(0x0A, [])
+
+    def get_position(self) -> int:
+        """获取当前脉冲位置"""
+        resp = self._send(0x32, [])
+        if len(resp) >= 8:
+            sign = resp[2]
+            val = struct.unpack('>I', resp[3:7])[0]
+            return -val if sign == 1 else val
+        return 0
+
+# ==============================================================================
+# 4. Liquid Sensor Driver (液位传感器)
+# ==============================================================================
+
+class XKCSensor:
+    """XKC RS485 液位传感器 (Modbus RTU)"""
+
+    def __init__(self, device_id: int, transport: TransportManager, threshold: int = 300):
+        self.id = device_id
+        self.transport = transport
+        self.threshold = threshold
+
+    def _crc(self, data: bytes) -> bytes:
+        crc = 0xFFFF
+        for byte in data:
+            crc ^= byte
+            for _ in range(8):
+                if crc & 0x0001: crc = (crc >> 1) ^ 0xA001
+                else: crc >>= 1
+        return struct.pack('<H', crc)
+
+    def read_level(self) -> Optional[Dict[str, Any]]:
+        """
+        读取液位。
+        返回: {'level': bool, 'rssi': int}
+        """
+        with self.transport.lock:
+            self.transport.clear_buffer()
+            # Modbus Read Registers: 01 03 00 01 00 02 CRC
+            payload = struct.pack('>HH', 0x0001, 0x0002)
+            msg = struct.pack('BB', self.id, 0x03) + payload
+            msg += self._crc(msg)
+            self.transport.write(msg)
+
+            # Read header
+            h = self.transport.read(3) # Addr, Func, Len
+            if len(h) < 3: return None
+            length = h[2]
+
+            # Read body + CRC
+            body = self.transport.read(length + 2)
+            if len(body) < length + 2:
+                # Firmware bug fix specific to some modules
+                if len(body) == 4 and length == 4:
+                    pass
+                else:
+                    return None
+
+            data = body[:-2]
+            if len(data) == 2:
+                rssi = data[1]
+            elif len(data) >= 4:
+                rssi = (data[2] << 8) | data[3]
+            else:
+                return None
+
+            return {
+                'level': rssi > self.threshold,
+                'rssi': rssi
+            }
+
+# ==============================================================================
+# 5. Main Device Class (ChinweDevice)
+# ==============================================================================
+
+class ChinweDevice(UniversalDriver):
+    """
+    ChinWe 工作站主驱动
+    继承自 UniversalDriver，管理所有子设备（泵、电机、传感器）
+    """
+
+    def __init__(self, port: str = "192.168.1.200:8899", baudrate: int = 9600,
+                 pump_ids: List[int] = None, motor_ids: List[int] = None,
+                 sensor_id: int = 6, sensor_threshold: int = 300,
+                 timeout: float = 10.0):
+        """
+        初始化 ChinWe 工作站
+        :param port: 串口号 或 IP:Port
+        :param baudrate: 串口波特率
+        :param pump_ids: 注射泵 ID列表 (默认 [1, 2, 3])
+        :param motor_ids: 步进电机 ID列表 (默认 [4, 5])
+        :param sensor_id: 液位传感器 ID (默认 6)
+        :param sensor_threshold: 传感器液位判定阈值
+        :param timeout: 通信超时时间 (默认 10秒)
+        """
+        super().__init__()
+        self.port = port
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.mgr = None
         self._is_connected = False
-        self.connect()
-    
+
+        # 默认配置
+        if pump_ids is None: pump_ids = [1, 2, 3]
+        if motor_ids is None: motor_ids = [4, 5]
+
+        # 配置信息
+        self.pump_ids = pump_ids
+        self.motor_ids = motor_ids
+        self.sensor_id = sensor_id
+        self.sensor_threshold = sensor_threshold
+
+        # 子设备实例容器
+        self.pumps: Dict[int, SyringePump] = {}
+        self.motors: Dict[int, EmmMotor] = {}
+        self.sensor: Optional[XKCSensor] = None
+
+        # 轮询线程控制
+        self._stop_event = threading.Event()
+        self._poll_thread = None
+
+        # 实时状态缓存
+        self.status_cache = {
+             "sensor_rssi": 0,
+             "sensor_level": False,
+             "connected": False
+        }
+
+        # 自动连接
+        if self.port:
+            self.connect()
+
+    def connect(self) -> bool:
+        if self._is_connected: return True
+        try:
+            self.logger.info(f"Connecting to {self.port} (timeout={self.timeout})...")
+            self.mgr = TransportManager(self.port, baudrate=self.baudrate, timeout=self.timeout, logger=self.logger)
+
+            # 初始化所有泵
+            for pid in self.pump_ids:
+                self.pumps[pid] = SyringePump(pid, self.mgr)
+
+            # 初始化所有电机
+            for mid in self.motor_ids:
+                self.motors[mid] = EmmMotor(mid, self.mgr)
+
+            # 初始化传感器
+            self.sensor = XKCSensor(self.sensor_id, self.mgr, self.sensor_threshold)
+
+            self._is_connected = True
+            self.status_cache["connected"] = True
+
+            # 启动轮询线程
+            self._start_polling()
+            return True
+        except Exception as e:
+            self.logger.error(f"Connection failed: {e}")
+            self._is_connected = False
+            self.status_cache["connected"] = False
+            return False
+
+    def disconnect(self):
+        self._stop_event.set()
+        if self._poll_thread:
+            self._poll_thread.join(timeout=2.0)
+
+        if self.mgr:
+            self.mgr.close()
+
+        self._is_connected = False
+        self.status_cache["connected"] = False
+        self.logger.info("Disconnected.")
+
+    def _start_polling(self):
+        """启动传感器轮询线程"""
+        if self._poll_thread and self._poll_thread.is_alive():
+            return
+
+        self._stop_event.clear()
+        self._poll_thread = threading.Thread(target=self._polling_loop, daemon=True, name="ChinwePoll")
+        self._poll_thread.start()
+
+    def _polling_loop(self):
+        """轮询主循环"""
+        self.logger.info("Sensor polling started.")
+        error_count = 0
+        while not self._stop_event.is_set():
+            if not self._is_connected or not self.sensor:
+                time.sleep(1)
+                continue
+
+            try:
+                # 获取传感器数据
+                data = self.sensor.read_level()
+                if data:
+                    self.status_cache["sensor_rssi"] = data['rssi']
+                    self.status_cache["sensor_level"] = data['level']
+                    error_count = 0
+                else:
+                    error_count += 1
+
+                # 降低轮询频率防止总线拥塞
+                time.sleep(0.2)
+
+            except Exception as e:
+                error_count += 1
+                if error_count > 10: # 连续错误记录日志
+                    # self.logger.error(f"Polling error: {e}")
+                    error_count = 0
+                time.sleep(1)
+
+    # --- 对外暴露属性 (Properties) ---
+
+    @property
+    def sensor_level(self) -> bool:
+        return self.status_cache["sensor_level"]
+
+    @property
+    def sensor_rssi(self) -> int:
+        return self.status_cache["sensor_rssi"]
+
     @property
     def is_connected(self) -> bool:
-        """获取连接状态"""
-        return self._is_connected and self.serial_port and self.serial_port.is_open
-    
-    @property
-    def voltage(self) -> float:
-        """获取电源电压值"""
-        return self._voltage
-    
-    @property
-    def ec_value(self) -> float:
-        """获取电导率值 (ms/cm)"""
-        return self._ec_value
+        return self._is_connected
 
-    @property
-    def ec_adc_value(self) -> int:
-        """获取EC ADC原始值"""
-        return self._ec_adc_value
-    
+    # --- 对外功能指令 (Actions) ---
 
-    @property
-    def device_status(self) -> Dict[str, any]:
-        """
-        获取设备状态信息
-        
-        Returns:
-            包含设备状态的字典
-        """
-        return {
-            "connected": self.is_connected,
-            "port": self.port,
-            "baudrate": self.baudrate,
-            "voltage": self.voltage,
-            "ec_value": self.ec_value,
-            "ec_adc_value": self.ec_adc_value
-        }
-    
-    def connect(self, port: Optional[str] = None, baudrate: Optional[int] = None) -> bool:
-        """
-        连接到串口设备
-        
-        Args:
-            port: 串口名称，如果为None则使用初始化时的port或自动检测
-            baudrate: 波特率，如果为None则使用初始化时的baudrate
-            
-        Returns:
-            连接是否成功
-        """
-        if self.is_connected:
+    def pump_initialize(self, pump_id: int, drain_port=0, output_port=0, speed=10):
+        """指定泵初始化"""
+        pump_id = int(pump_id)
+        if pump_id in self.pumps:
+            self.pumps[pump_id].initialize(drain_port, output_port, speed)
+            self.pumps[pump_id].wait_until_idle()
             return True
-            
-        target_port = port or self.port
-        target_baudrate = baudrate or self.baudrate
-        
-        try:
-            self.serial_port = serial.Serial(target_port, target_baudrate, timeout=0.5)
-            self._is_connected = True
-            self.port = target_port
-            self.baudrate = target_baudrate
-            connect_allow_times = 5
-            while not self.serial_port.is_open and connect_allow_times > 0:
-                time.sleep(0.5)
-                connect_allow_times -= 1
-                print(f"尝试连接到 {target_port} @ {target_baudrate}，剩余尝试次数: {connect_allow_times}", self.debug)
-                raise ValueError("串口未打开，请检查设备连接")
-            print(f"已连接到 {target_port} @ {target_baudrate}", self.debug)
-            threading.Thread(target=self._read_data, daemon=True).start()
+        return False
+
+    def pump_aspirate(self, pump_id: int, volume: int, valve_port: int):
+        """
+        泵吸液 (阻塞)
+        :param valve_port: 阀门端口 (1-8)
+        """
+        pump_id = int(pump_id)
+        valve_port = int(valve_port)
+        if pump_id in self.pumps:
+            pump = self.pumps[pump_id]
+            # 1. 切换阀门
+            pump.switch_valve(valve_port)
+            pump.wait_until_idle()
+            # 2. 吸液
+            pump.aspirate(volume)
+            pump.wait_until_idle()
             return True
-        except Exception as e:
-            print(f"ChinweDevice连接失败: {e}")
-            self._is_connected = False
-            return False
-    
-    def disconnect(self) -> bool:
+        return False
+
+    def pump_dispense(self, pump_id: int, volume: int, valve_port: int):
         """
-        断开串口连接
-        
-        Returns:
-            断开是否成功
+        泵排液 (阻塞)
+        :param valve_port: 阀门端口 (1-8)
         """
-        if self.serial_port and self.serial_port.is_open:
-            try:
-                self.serial_port.close()
-                self._is_connected = False
-                print("已断开串口连接")
-                return True
-            except Exception as e:
-                print(f"断开连接失败: {e}")
-                return False
+        pump_id = int(pump_id)
+        valve_port = int(valve_port)
+        if pump_id in self.pumps:
+            pump = self.pumps[pump_id]
+            # 1. 切换阀门
+            pump.switch_valve(valve_port)
+            pump.wait_until_idle()
+            # 2. 排液
+            pump.dispense(volume)
+            pump.wait_until_idle()
+            return True
+        return False
+
+    def pump_valve(self, pump_id: int, port: int):
+        """泵切换阀门 (阻塞)"""
+        pump_id = int(pump_id)
+        port = int(port)
+        if pump_id in self.pumps:
+            pump = self.pumps[pump_id]
+            pump.switch_valve(port)
+            pump.wait_until_idle()
+            return True
+        return False
+
+    def motor_run_continuous(self, motor_id: int, speed: int, direction: str = "顺时针"):
+        """
+        电机一直旋转 (速度模式)
+        :param direction: "顺时针" or "逆时针"
+        """
+        motor_id = int(motor_id)
+        if motor_id not in self.motors: return False
+
+        dir_val = 0 if direction == "顺时针" else 1
+        self.motors[motor_id].run_speed(speed, dir_val)
         return True
-    
-    def _send_motor_command(self, command: str) -> bool:
+
+    def motor_rotate_quarter(self, motor_id: int, speed: int = 60, direction: str = "顺时针"):
         """
-        发送电机控制命令
-        
-        Args:
-            command: 电机命令字符串，例如 "M 1 CW 1.5"
-            
-        Returns:
-            发送是否成功
+        电机旋转1/4圈 (阻塞)
+        假设电机设置为 3200 脉冲/圈，1/4圈 = 800脉冲
         """
-        if not self.is_connected:
-            print("设备未连接")
-            return False
-            
-        try:
-            self.serial_port.write((command + "\n").encode('utf-8'))
-            print(f"发送命令: {command}")
+        motor_id = int(motor_id)
+        if motor_id not in self.motors: return False
+
+        pulses = 800
+        dir_val = 0 if direction == "顺时针" else 1
+
+        self.motors[motor_id].run_position(pulses, speed, dir_val, absolute=False)
+
+        # 预估时间阻塞 (单位: 分钟 -> 秒)
+        # Time(s) = revs / (RPM/60). revs = 0.25. time = 15 / RPM.
+        estimated_time = 15.0 / max(1, speed)
+        time.sleep(estimated_time + 0.5)
+
+        return True
+
+    def motor_stop(self, motor_id: int):
+        """电机停止"""
+        motor_id = int(motor_id)
+        if motor_id in self.motors:
+            self.motors[motor_id].stop()
             return True
-        except Exception as e:
-            print(f"发送命令失败: {e}")
-            return False
-    
-    def rotate_motor(self, motor_id: int, turns: float, clockwise: bool = True) -> bool:
-        """
-        使电机转动指定圈数
-        
-        Args:
-            motor_id: 电机ID（1, 2, 3...）
-            turns: 转动圈数，支持小数
-            clockwise: True为顺时针，False为逆时针
-            
-        Returns:
-            命令发送是否成功
-        """
-        if clockwise:
-            command = f"M {motor_id} CW {turns}"
-        else:
-            command = f"M {motor_id} CCW {turns}"
-        return self._send_motor_command(command)
+        return False
 
-    def set_motor_speed(self, motor_id: int, speed: float) -> bool:
+    def wait_sensor_level(self, target_state: str = "有液", timeout: int = 30) -> bool:
         """
-        设置电机转速（如果设备支持）
-        
-        Args:
-            motor_id: 电机ID（1, 2, 3...）
-            speed: 转速值
-            
-        Returns:
-            命令发送是否成功
+        等待传感器达到指定电平
+        :param target_state: "有液" or "无液"
         """
-        command = f"M {motor_id} SPEED {speed}"
-        return self._send_motor_command(command)
+        target_bool = True if target_state == "有液" else False
 
-    def _read_data(self) -> List[str]:
-        """
-        读取串口数据并解析
-        
-        Returns:
-            读取到的数据行列表
-        """
-        print("开始读取串口数据...")
-        if not self.is_connected:
-            return []
-            
-        data_lines = []
-        try:
-            while self.serial_port.in_waiting:
-                time.sleep(0.1)  # 等待数据稳定
-                try:
-                    line = self.serial_port.readline().decode('utf-8', errors='ignore').strip()
-                    if line:
-                        data_lines.append(line)
-                        self._parse_sensor_data(line)
-                except Exception as ex:
-                    print(f"解码数据错误: {ex}")
-        except Exception as e:
-            print(f"读取串口数据错误: {e}")
-            
-        return data_lines
-    
-    def _parse_sensor_data(self, line: str) -> None:
-        """
-        解析传感器数据
-        
-        Args:
-            line: 接收到的数据行
-        """
-        # 解析电源电压
-        if "电源电压" in line:
-            try:
-                val = float(line.split("：")[1].replace("V", "").strip())
-                self._voltage = val
-                if self.debug:
-                    print(f"电源电压更新: {val}V")
-            except Exception:
-                pass
+        self.logger.info(f"Wait sensor: {target_state} ({target_bool}), timeout: {timeout}")
+        start = time.time()
+        while time.time() - start < timeout:
+            if self.sensor_level == target_bool:
+                return True
+            time.sleep(0.1)
+        self.logger.warning("Wait sensor level timeout")
+        return False
 
-        # 解析电导率和ADC原始值（支持两种格式）
-        if "电导率" in line and "ADC原始值" in line:
-            try:
-                # 支持格式如：电导率：2.50ms/cm, ADC原始值：2052
-                ec_match = re.search(r"电导率[:：]\s*([\d\.]+)", line)
-                adc_match = re.search(r"ADC原始值[:：]\s*(\d+)", line)
-                if ec_match:
-                    ec_val = float(ec_match.group(1))
-                    self._ec_value = ec_val
-                    if self.debug:
-                        print(f"电导率更新: {ec_val:.2f} ms/cm")
-                if adc_match:
-                    adc_val = int(adc_match.group(1))
-                    self._ec_adc_value = adc_val
-                    if self.debug:
-                        print(f"EC ADC原始值更新: {adc_val}")
-            except Exception:
-                pass
-        # 仅电导率，无ADC原始值
-        elif "电导率" in line:
-            try:
-                val = float(line.split("：")[1].replace("ms/cm", "").strip())
-                self._ec_value = val
-                if self.debug:
-                    print(f"电导率更新: {val:.2f} ms/cm")
-            except Exception:
-                pass
-        # 仅ADC原始值（如有分开回传场景）
-        elif "ADC原始值" in line:
-            try:
-                adc_val = int(line.split("：")[1].strip())
-                self._ec_adc_value = adc_val
-                if self.debug:
-                    print(f"EC ADC原始值更新: {adc_val}")
-            except Exception:
-                pass
-    
-    def spin_when_ec_ge_0():
-        pass
-    
+    def wait_time(self, duration: int) -> bool:
+        """
+        等待指定时间 (秒)
+        :param duration: 秒
+        """
+        self.logger.info(f"Waiting for {duration} seconds...")
+        time.sleep(duration)
+        return True
+
+    def execute_command_from_outer(self, command_dict: Dict[str, Any]) -> bool:
+        """支持标准 JSON 指令调用"""
+        return super().execute_command_from_outer(command_dict)
 
-def main():
-    """测试函数"""
-    print("=== ChinWe设备测试 ===")
-    
-    # 创建设备实例
-    device = ChinweDevice("/dev/tty.usbserial-A5069RR4", debug=True)
-    try:
-        # 测试5: 发送电机命令
-        print("\n5. 发送电机命令测试:")
-        print("  5.3 使用通用函数控制电机20顺时针转2圈:")
-        device.rotate_motor(2, 20.0, clockwise=True)
-        time.sleep(0.5)
-    finally:
-        time.sleep(10)
-        # 测试7: 断开连接
-        print("\n7. 断开连接:")
-        device.disconnect()
 if __name__ == "__main__":
-    main()
+    # Test
+    logging.basicConfig(level=logging.INFO)
+    dev = ChinweDevice(port="192.168.31.201:8899")
+    try:
+        if dev.is_connected:
+            print(f"Status: Level={dev.sensor_level}, RSSI={dev.sensor_rssi}")
+
+            # Test pump 1
+            # dev.pump_valve(1, 1)
+            # dev.pump_move(1, 1000, "aspirate")
+
+            # Test motor 4
+             # dev.motor_run(4, 60, 0, 2)
+
+            for _ in range(5):
+                print(f"Level={dev.sensor_level}, RSSI={dev.sensor_rssi}")
+                time.sleep(1)
+    finally:
+        dev.disconnect()

unilabos/devices/virtual/virtual_multiway_valve.py

@@ -7,7 +7,7 @@ class VirtualMultiwayValve:
     """
     虚拟九通阀门 - 0号位连接transfer pump，1-8号位连接其他设备 🔄
     """
-    def __init__(self, port: str = "VIRTUAL", positions: int = 8):
+    def __init__(self, port: str = "VIRTUAL", positions: int = 8, **kwargs):
         self.port = port
         self.max_positions = positions  # 1-8号位
         self.total_positions = positions + 1  # 0-8号位，共9个位置

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

@@ -0,0 +1,197 @@
+{
+    "token": "",
+    "request_time": "2025-12-24T15:32:09.2148671+08:00",
+    "data": {
+        "orderId": "3a1e614d-a082-c44a-60be-68647a35e6f1",
+        "orderCode": "BSO2025122400024",
+        "orderName": "DP20251224001",
+        "startTime": "2025-12-24T14:51:50.549848",
+        "endTime": "2025-12-24T15:32:09.000765",
+        "status": "30",
+        "workflowStatus": "completed",
+        "completionTime": "2025-12-24T15:32:09.000765",
+        "usedMaterials": [
+            {
+                "materialId": "3a1e614b-53a6-0ec4-10bd-956b240c0f04",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614b-4da7-cf62-3a40-7e5879255c0c",
+                "locationId": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-53a7-2850-42c8-a7a2de8ff4bf",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-4da6-ac9d-02be-4b0716796bd2",
+                "locationId": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614d-9c9a-fafa-4757-c7411b03bd9f",
+                "locationId": "3a1abd46-18fe-1f56-6ced-a1f7fe08e36c",
+                "typemode": "0",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-6917-b8f9-7987-7a33a3792829",
+                "locationId": "3a19da43-57b5-294f-d663-154a1cc32270",
+                "typemode": "2",
+                "usedQuantity": 3.51,
+                "realQuantity": 3.5155000000000000000000000000
+            },
+            {
+                "materialId": "3a1e614b-6914-d92b-e348-f52e13817a5d",
+                "locationId": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+                "typemode": "2",
+                "usedQuantity": 0.33,
+                "realQuantity": 0.3336000000000000000000000000
+            }
+        ]
+    }
+}
+
+{
+    "token": "",
+    "request_time": "2025-12-24T15:32:09.9999039+08:00",
+    "data": {
+        "orderId": "3a1e614d-a0a2-f7a9-9360-610021c9479d",
+        "orderCode": "BSO2025122400025",
+        "orderName": "DP20251224002",
+        "startTime": "2025-12-24T14:53:03.44259",
+        "endTime": "2025-12-24T15:32:09.828261",
+        "status": "30",
+        "workflowStatus": "completed",
+        "completionTime": "2025-12-24T15:32:09.828261",
+        "usedMaterials": [
+            {
+                "materialId": "3a1e614b-4da7-6527-9f1c-b39e3de8ff2b",
+                "locationId": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-53a6-0ec4-10bd-956b240c0f04",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614b-4da6-ac9d-02be-4b0716796bd2",
+                "locationId": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614b-53a8-8474-cac8-0fd7d349e4b2",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614d-9c9a-fafa-4757-c7411b03bd9f",
+                "locationId": null,
+                "typemode": "0",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-6917-b8f9-7987-7a33a3792829",
+                "locationId": "3a19da43-57b5-294f-d663-154a1cc32270",
+                "typemode": "2",
+                "usedQuantity": 0.7,
+                "realQuantity": 0
+            },
+            {
+                "materialId": "3a1e614b-6914-d92b-e348-f52e13817a5d",
+                "locationId": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+                "typemode": "2",
+                "usedQuantity": 1.15,
+                "realQuantity": 1.1627000000000000000000000000
+            }
+        ]
+    }
+}
+
+{
+    "token": "",
+    "request_time": "2025-12-24T15:34:00.4139986+08:00",
+    "data": {
+        "orderId": "3a1e614d-a0cd-81ca-9f7f-2f4e93af01cd",
+        "orderCode": "BSO2025122400026",
+        "orderName": "DP20251224003",
+        "startTime": "2025-12-24T14:54:24.443344",
+        "endTime": "2025-12-24T15:34:00.26321",
+        "status": "30",
+        "workflowStatus": "completed",
+        "completionTime": "2025-12-24T15:34:00.26321",
+        "usedMaterials": [
+            {
+                "materialId": "3a1e614b-4da6-ac9d-02be-4b0716796bd2",
+                "locationId": "3a19deae-2c7a-b9eb-f4e3-e308e0cf839a",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614b-4da8-b678-f204-207076f09c83",
+                "locationId": "3a19deae-2c7a-b9eb-f4e3-e308e0cf839a",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-53a6-0ec4-10bd-956b240c0f04",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 2,
+                "realQuantity": 2
+            },
+            {
+                "materialId": "3a1e614b-53a8-e3f2-dee0-fa97b600b652",
+                "locationId": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
+                "typemode": "1",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614d-9c9a-fafa-4757-c7411b03bd9f",
+                "locationId": null,
+                "typemode": "0",
+                "usedQuantity": 1,
+                "realQuantity": 1
+            },
+            {
+                "materialId": "3a1e614b-6917-b8f9-7987-7a33a3792829",
+                "locationId": "3a19da43-57b5-294f-d663-154a1cc32270",
+                "typemode": "2",
+                "usedQuantity": 2.0,
+                "realQuantity": 2.0075000000000000000000000000
+            },
+            {
+                "materialId": "3a1e614b-6914-d92b-e348-f52e13817a5d",
+                "locationId": "3a19da56-1379-ff7c-1745-07e200b44ce2",
+                "typemode": "2",
+                "usedQuantity": 1.2,
+                "realQuantity": 1.2126000000000000000000000000
+            }
+        ]
+    }
+}

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/bioyond_cell/多订单返回说明.md

@@ -0,0 +1,113 @@
+# Bioyond Cell 工作站 - 多订单返回示例
+
+本文档说明了 `create_orders` 函数如何收集并返回所有订单的完成报文。
+
+## 问题描述
+
+之前的实现只会等待并返回第一个订单的完成报文，如果有多个订单（例如从 Excel 解析出 3 个订单），只能得到第一个订单的推送信息。
+
+## 解决方案
+
+修改后的 `create_orders` 函数现在会：
+
+1. **提取所有 orderCode**：从 LIMS 接口返回的 `data` 列表中提取所有订单编号
+2. **逐个等待完成**：遍历所有 orderCode，调用 `wait_for_order_finish` 等待每个订单完成
+3. **收集所有报文**：将每个订单的完成报文存入 `all_reports` 列表
+4. **统一返回**：返回包含所有订单报文的 JSON 格式数据
+
+## 返回格式
+
+```json
+{
+    "status": "all_completed",
+    "total_orders": 3,
+    "reports": [
+        {
+            "token": "",
+            "request_time": "2025-12-24T15:32:09.2148671+08:00",
+            "data": {
+                "orderId": "3a1e614d-a082-c44a-60be-68647a35e6f1",
+                "orderCode": "BSO2025122400024",
+                "orderName": "DP20251224001",
+                "status": "30",
+                "workflowStatus": "completed",
+                "usedMaterials": [...]
+            }
+        },
+        {
+            "token": "",
+            "request_time": "2025-12-24T15:32:09.9999039+08:00",
+            "data": {
+                "orderId": "3a1e614d-a0a2-f7a9-9360-610021c9479d",
+                "orderCode": "BSO2025122400025",
+                "orderName": "DP20251224002",
+                "status": "30",
+                "workflowStatus": "completed",
+                "usedMaterials": [...]
+            }
+        },
+        {
+            "token": "",
+            "request_time": "2025-12-24T15:34:00.4139986+08:00",
+            "data": {
+                "orderId": "3a1e614d-a0cd-81ca-9f7f-2f4e93af01cd",
+                "orderCode": "BSO2025122400026",
+                "orderName": "DP20251224003",
+                "status": "30",
+                "workflowStatus": "completed",
+                "usedMaterials": [...]
+            }
+        }
+    ],
+    "original_response": {...}
+}
+```
+
+## 使用示例
+
+```python
+# 调用 create_orders
+result = workstation.create_orders("20251224.xlsx")
+
+# 访问返回数据
+print(f"总订单数: {result['total_orders']}")
+print(f"状态: {result['status']}")
+
+# 遍历所有订单的报文
+for i, report in enumerate(result['reports'], 1):
+    order_data = report.get('data', {})
+    print(f"\n订单 {i}:")
+    print(f"  orderCode: {order_data.get('orderCode')}")
+    print(f"  orderName: {order_data.get('orderName')}")
+    print(f"  status: {order_data.get('status')}")
+    print(f"  使用物料数: {len(order_data.get('usedMaterials', []))}")
+```
+
+## 控制台输出示例
+
+```
+[create_orders] 即将提交订单数量: 3
+[create_orders] 接口返回: {...}
+[create_orders] 等待 3 个订单完成: ['BSO2025122400024', 'BSO2025122400025', 'BSO2025122400026']
+[create_orders] 正在等待第 1/3 个订单: BSO2025122400024
+[create_orders] ✓ 订单 BSO2025122400024 完成
+[create_orders] 正在等待第 2/3 个订单: BSO2025122400025
+[create_orders] ✓ 订单 BSO2025122400025 完成
+[create_orders] 正在等待第 3/3 个订单: BSO2025122400026
+[create_orders] ✓ 订单 BSO2025122400026 完成
+[create_orders] 所有订单已完成，共收集 3 个报文
+实验记录本========================create_orders========================
+返回报文数量: 3
+报文 1: orderCode=BSO2025122400024, status=30
+报文 2: orderCode=BSO2025122400025, status=30
+报文 3: orderCode=BSO2025122400026, status=30
+========================
+```
+
+## 关键改进
+
+1. ✅ **等待所有订单**：不再只等待第一个订单，而是遍历所有 orderCode
+2. ✅ **收集完整报文**：每个订单的完整推送报文都被保存在 `reports` 数组中
+3. ✅ **详细日志**：清晰显示正在等待哪个订单，以及完成情况
+4. ✅ **错误处理**：即使某个订单失败，也会记录其状态信息
+5. ✅ **统一格式**：返回的 JSON 格式便于后续处理和分析

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -47,8 +47,8 @@ class BioyondV1RPC(BaseRequest):
         super().__init__()
         print("开始初始化 BioyondV1RPC")
         self.config = config
-        self.api_key = config["api_key"]
-        self.host = config["api_host"]
+        self.api_key = config.get("api_key", "")
+        self.host = config.get("api_host", "") or config.get("base_url", "")
         self._logger = SimpleLogger()
         self.material_cache = {}
         self._load_material_cache()
@@ -61,7 +61,7 @@ class BioyondV1RPC(BaseRequest):
 
         :return: 当前时间的 ISO 8601 格式字符串
         """
-        current_time = datetime.now(timezone.utc).isoformat(
+        current_time = datetime.now().isoformat(
             timespec='milliseconds'
         )
         # 替换时区部分为 'Z'
@@ -212,14 +212,8 @@ class BioyondV1RPC(BaseRequest):
             })
 
         if not response or response['code'] != 1:
-            if response:
-                error_msg = response.get('message', '未知错误')
-                print(f"[ERROR] 物料入库失败: code={response.get('code')}, message={error_msg}")
-            else:
-                print(f"[ERROR] 物料入库失败: API 无响应")
             return {}
-        # 入库成功时，即使没有 data 字段，也返回成功标识
-        return response.get("data") or {"success": True}
+        return response.get("data", {})
 
     def delete_material(self, material_id: str) -> dict:
         """
@@ -239,7 +233,7 @@ class BioyondV1RPC(BaseRequest):
         return response.get("data", {})
 
     def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
-        """指定库位出库物料（通过库位名称）"""
+        """指定库位出库物料"""
         location_id = LOCATION_MAPPING.get(location_name, location_name)
 
         params = {
@@ -257,36 +251,7 @@ class BioyondV1RPC(BaseRequest):
             })
 
         if not response or response['code'] != 1:
-            return None
-        return response
-
-    def material_outbound_by_id(self, material_id: str, location_id: str, quantity: int) -> dict:
-        """指定库位出库物料（直接使用location_id）
-
-        Args:
-            material_id: 物料ID
-            location_id: 库位ID（不是库位名称，是UUID）
-            quantity: 数量
-
-        Returns:
-            dict: API响应，失败返回None
-        """
-        params = {
-            "materialId": material_id,
-            "locationId": location_id,
-            "quantity": quantity
-        }
-
-        response = self.post(
-            url=f'{self.host}/api/lims/storage/outbound',
-            params={
-                "apiKey": self.api_key,
-                "requestTime": self.get_current_time_iso8601(),
-                "data": params
-            })
-
-        if not response or response['code'] != 1:
-            return None
+            return {}
         return response
 
     # ==================== 工作流查询相关接口 ====================
@@ -507,7 +472,7 @@ class BioyondV1RPC(BaseRequest):
             return {}
 
         response = self.post(
-            url=f'{self.host}/api/lims/order/project-order-report',
+            url=f'{self.host}/api/lims/order/order-report',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -684,7 +649,7 @@ class BioyondV1RPC(BaseRequest):
     def scheduler_pause(self) -> int:
         """描述：暂停调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/pause',
+            url=f'{self.host}/api/lims/scheduler/scheduler-pause',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -695,9 +660,8 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_continue(self) -> int:
-        """描述：继续调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/continue',
+            url=f'{self.host}/api/lims/scheduler/scheduler-continue',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -710,7 +674,7 @@ class BioyondV1RPC(BaseRequest):
     def scheduler_stop(self) -> int:
         """描述：停止调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/stop',
+            url=f'{self.host}/api/lims/scheduler/scheduler-stop',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -721,9 +685,9 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_reset(self) -> int:
-        """描述：复位调度器"""
+        """描述：重置调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/reset',
+            url=f'{self.host}/api/lims/scheduler/scheduler-reset',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -739,10 +703,10 @@ class BioyondV1RPC(BaseRequest):
         """预加载材料列表到缓存中"""
         try:
             print("正在加载材料列表缓存...")
-
+            
             # 加载所有类型的材料：耗材(0)、样品(1)、试剂(2)
-            material_types = [0, 1, 2]
-
+            material_types = [1, 2]
+            
             for type_mode in material_types:
                 print(f"正在加载类型 {type_mode} 的材料...")
                 stock_query = f'{{"typeMode": {type_mode}, "includeDetail": true}}'
@@ -759,7 +723,7 @@ class BioyondV1RPC(BaseRequest):
                     material_id = material.get("id")
                     if material_name and material_id:
                         self.material_cache[material_name] = material_id
-
+                    
                     # 处理样品板等容器中的detail材料
                     detail_materials = material.get("detail", [])
                     for detail_material in detail_materials:
@@ -795,4 +759,4 @@ class BioyondV1RPC(BaseRequest):
 
     def get_available_materials(self):
         """获取所有可用的材料名称列表"""
-        return list(self.material_cache.keys())
+        return list(self.material_cache.keys())

unilabos/devices/workstation/bioyond_studio/config.py

@@ -2,141 +2,332 @@
 """
 配置文件 - 包含所有配置信息和映射关系
 """
+import os
 
-# API配置
+# ==================== API 基础配置 ====================
+# BioyondCellWorkstation 默认配置（包含所有必需参数）
 API_CONFIG = {
-    "api_key": "",
-    "api_host": ""
-}
-
-# 工作流映射配置
-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.11.118: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.206"),  # HTTP服务监听地址，监听计算机飞连ip地址
+    "HTTP_port": int(os.getenv("BIOYOND_HTTP_PORT", "8080")),
+    "debug_mode": False,# 调试模式
 }
 
 # 库位映射配置
 WAREHOUSE_MAPPING = {
-    "粉末堆栈": {
+    "粉末加样头堆栈": {
         "uuid": "",
         "site_uuids": {
-            # 样品板
-            "A1": "3a14198e-6929-31f0-8a22-0f98f72260df",
-            "A2": "3a14198e-6929-4379-affa-9a2935c17f99",
-            "A3": "3a14198e-6929-56da-9a1c-7f5fbd4ae8af",
-            "A4": "3a14198e-6929-5e99-2b79-80720f7cfb54",
-            "B1": "3a14198e-6929-f525-9a1b-1857552b28ee",
-            "B2": "3a14198e-6929-bf98-0fd5-26e1d68bf62d",
-            "B3": "3a14198e-6929-2d86-a468-602175a2b5aa",
-            "B4": "3a14198e-6929-1a98-ae57-e97660c489ad",
-            # 分装板
-            "C1": "3a14198e-6929-46fe-841e-03dd753f1e4a",
-            "C2": "3a14198e-6929-1bc9-a9bd-3b7ca66e7f95",
-            "C3": "3a14198e-6929-72ac-32ce-9b50245682b8",
-            "C4": "3a14198e-6929-3bd8-e6c7-4a9fd93be118",
-            "D1": "3a14198e-6929-8a0b-b686-6f4a2955c4e2",
-            "D2": "3a14198e-6929-dde1-fc78-34a84b71afdf",
-            "D3": "3a14198e-6929-a0ec-5f15-c0f9f339f963",
-            "D4": "3a14198e-6929-7ac8-915a-fea51cb2e884"
+            "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": {
-            "A1": "3a14198e-d724-e036-afdc-2ae39a7f3383",
-            "A2": "3a14198e-d724-afa4-fc82-0ac8a9016791",
-            "A3": "3a14198e-d724-ca48-bb9e-7e85751e55b6",
-            "A4": "3a14198e-d724-df6d-5e32-5483b3cab583",
-            "B1": "3a14198e-d724-d818-6d4f-5725191a24b5",
-            "B2": "3a14198e-d724-be8a-5e0b-012675e195c6",
-            "B3": "3a14198e-d724-cc1e-5c2c-228a130f40a8",
-            "B4": "3a14198e-d724-1e28-c885-574c3df468d0",
-            "C1": "3a14198e-d724-b5bb-adf3-4c5a0da6fb31",
-            "C2": "3a14198e-d724-ab4e-48cb-817c3c146707",
-            "C3": "3a14198e-d724-7f18-1853-39d0c62e1d33",
-            "C4": "3a14198e-d724-28a2-a760-baa896f46b66",
-            "D1": "3a14198e-d724-d378-d266-2508a224a19f",
-            "D2": "3a14198e-d724-f56e-468b-0110a8feb36a",
-            "D3": "3a14198e-d724-0cf1-dea9-a1f40fe7e13c",
-            "D4": "3a14198e-d724-0ddd-9654-f9352a421de9"
+            "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": {
-            "A1": "3a14198c-c2cf-8b40-af28-b467808f1c36",
-            "A2": "3a14198c-c2d0-f3e7-871a-e470d144296f",
-            "A3": "3a14198c-c2d0-dc7d-b8d0-e1d88cee3094",
-            "A4": "3a14198c-c2d0-2070-efc8-44e245f10c6f",
-            "B1": "3a14198c-c2d0-354f-39ad-642e1a72fcb8",
-            "B2": "3a14198c-c2d0-1559-105d-0ea30682cab4",
-            "B3": "3a14198c-c2d0-725e-523d-34c037ac2440",
-            "B4": "3a14198c-c2d0-efce-0939-69ca5a7dfd39"
+            "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_MAPPINGS = {
-    "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""),
-    "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+    "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"),
 }
 
-LOCATION_MAPPING = {}
+WORKFLOW_MAPPINGS = {}
 
-ACTION_NAMES = {}
-
-HTTP_SERVICE_CONFIG = {}
+LOCATION_MAPPING = {}

unilabos/devices/workstation/bioyond_studio/dispensing_station.py

@@ -1,7 +1,5 @@
 from datetime import datetime
 import json
-import time
-from typing import Optional, Dict, Any
 
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondException
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
@@ -25,9 +23,6 @@ class BioyondDispensingStation(BioyondWorkstation):
         # self._logger = SimpleLogger()
         # self.is_running = False
 
-        # 用于跟踪任务完成状态的字典: {orderCode: {status, order_id, timestamp}}
-        self.order_completion_status = {}
-
     # 90%10%小瓶投料任务创建方法
     def create_90_10_vial_feeding_task(self,
                                        order_name: str = None,
@@ -275,45 +270,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             # 7. 调用create_order方法创建任务
             result = self.hardware_interface.create_order(json_str)
             self.hardware_interface._logger.info(f"创建90%10%小瓶投料任务结果: {result}")
-
-            # 8. 解析结果获取order_id
-            order_id = None
-            if isinstance(result, str):
-                # result 格式: "{'3a1d895c-4d39-d504-1398-18f5a40bac1e': [{'id': '...', ...}]}"
-                # 第一个键就是order_id (UUID)
-                try:
-                    # 尝试解析字符串为字典
-                    import ast
-                    result_dict = ast.literal_eval(result)
-                    # 获取第一个键作为order_id
-                    if result_dict and isinstance(result_dict, dict):
-                        first_key = list(result_dict.keys())[0]
-                        order_id = first_key
-                        self.hardware_interface._logger.info(f"✓ 成功提取order_id: {order_id}")
-                    else:
-                        self.hardware_interface._logger.warning(f"result_dict格式异常: {result_dict}")
-                except Exception as e:
-                    self.hardware_interface._logger.error(f"✗ 无法从结果中提取order_id: {e}, result类型={type(result)}")
-            elif isinstance(result, dict):
-                # 如果已经是字典
-                if result:
-                    first_key = list(result.keys())[0]
-                    order_id = first_key
-                    self.hardware_interface._logger.info(f"✓ 成功提取order_id(dict): {order_id}")
-
-            if not order_id:
-                self.hardware_interface._logger.warning(
-                    f"⚠ 未能提取order_id，result={result[:100] if isinstance(result, str) else result}"
-                )
-
-            # 返回成功结果和构建的JSON数据
-            return json.dumps({
-                "suc": True,
-                "order_code": order_code,
-                "order_id": order_id,
-                "result": result,
-                "order_params": order_data
-            })
+            return json.dumps({"suc": True})
 
         except BioyondException:
             # 重新抛出BioyondException
@@ -441,37 +398,7 @@ class BioyondDispensingStation(BioyondWorkstation):
             result = self.hardware_interface.create_order(json_str)
             self.hardware_interface._logger.info(f"创建二胺溶液配置任务结果: {result}")
 
-            # 8. 解析结果获取order_id
-            order_id = None
-            if isinstance(result, str):
-                try:
-                    import ast
-                    result_dict = ast.literal_eval(result)
-                    if result_dict and isinstance(result_dict, dict):
-                        first_key = list(result_dict.keys())[0]
-                        order_id = first_key
-                        self.hardware_interface._logger.info(f"✓ 成功提取order_id: {order_id}")
-                    else:
-                        self.hardware_interface._logger.warning(f"result_dict格式异常: {result_dict}")
-                except Exception as e:
-                    self.hardware_interface._logger.error(f"✗ 无法从结果中提取order_id: {e}")
-            elif isinstance(result, dict):
-                if result:
-                    first_key = list(result.keys())[0]
-                    order_id = first_key
-                    self.hardware_interface._logger.info(f"✓ 成功提取order_id(dict): {order_id}")
-
-            if not order_id:
-                self.hardware_interface._logger.warning(f"⚠ 未能提取order_id")
-
-            # 返回成功结果和构建的JSON数据
-            return json.dumps({
-                "suc": True,
-                "order_code": order_code,
-                "order_id": order_id,
-                "result": result,
-                "order_params": order_data
-            })
+            return json.dumps({"suc": True})
 
         except BioyondException:
             # 重新抛出BioyondException
@@ -572,24 +499,15 @@ class BioyondDispensingStation(BioyondWorkstation):
                         hold_m_name=hold_m_name
                     )
 
-                    # 解析返回结果以获取order_code和order_id
-                    result_data = json.loads(result) if isinstance(result, str) else result
-                    order_code = result_data.get("order_code")
-                    order_id = result_data.get("order_id")
-                    order_params = result_data.get("order_params", {})
-
                     results.append({
                         "index": idx + 1,
                         "name": name,
                         "success": True,
-                        "order_code": order_code,
-                        "order_id": order_id,
-                        "hold_m_name": hold_m_name,
-                        "order_params": order_params
+                        "hold_m_name": hold_m_name
                     })
                     success_count += 1
                     self.hardware_interface._logger.info(
-                        f"成功创建二胺溶液配置任务: {name}, order_code={order_code}, order_id={order_id}"
+                        f"成功创建二胺溶液配置任务: {name}"
                     )
 
                 except BioyondException as e:
@@ -615,17 +533,11 @@ class BioyondDispensingStation(BioyondWorkstation):
                         f"创建第 {idx + 1} 个任务时发生未知错误: {str(e)}"
                     )
 
-            # 提取所有成功任务的order_code和order_id
-            order_codes = [r["order_code"] for r in results if r["success"]]
-            order_ids = [r["order_id"] for r in results if r["success"]]
-
             # 返回汇总结果
             summary = {
                 "total": len(solutions),
                 "success": success_count,
                 "failed": failed_count,
-                "order_codes": order_codes,
-                "order_ids": order_ids,
                 "details": results
             }
 
@@ -634,13 +546,8 @@ class BioyondDispensingStation(BioyondWorkstation):
                 f"成功={success_count}, 失败={failed_count}"
             )
 
-            # 构建返回结果
-            summary["return_info"] = {
-                "order_codes": order_codes,
-                "order_ids": order_ids,
-            }
-
-            return summary
+            # 返回JSON字符串格式
+            return json.dumps(summary, ensure_ascii=False)
 
         except BioyondException:
             raise
@@ -706,15 +613,22 @@ class BioyondDispensingStation(BioyondWorkstation):
             if not all([name, main_portion is not None, titration_portion is not None, titration_solvent is not None]):
                 raise BioyondException("titration 数据缺少必要参数")
 
+            # 将main_portion平均分成3份作为90%物料（3个小瓶）
+            portion_90 = main_portion / 3
+
             # 调用单个任务创建方法
             result = self.create_90_10_vial_feeding_task(
                 order_name=f"90%10%小瓶投料-{name}",
                 speed=speed,
                 temperature=temperature,
                 delay_time=delay_time,
-                # 90%物料 - 主称固体直接使用main_portion
+                # 90%物料 - 主称固体平均分成3份
                 percent_90_1_assign_material_name=name,
-                percent_90_1_target_weigh=str(round(main_portion, 6)),
+                percent_90_1_target_weigh=str(round(portion_90, 6)),
+                percent_90_2_assign_material_name=name,
+                percent_90_2_target_weigh=str(round(portion_90, 6)),
+                percent_90_3_assign_material_name=name,
+                percent_90_3_target_weigh=str(round(portion_90, 6)),
                 # 10%物料 - 滴定固体 + 滴定溶剂（只使用第1个10%小瓶）
                 percent_10_1_assign_material_name=name,
                 percent_10_1_target_weigh=str(round(titration_portion, 6)),
@@ -723,54 +637,29 @@ class BioyondDispensingStation(BioyondWorkstation):
                 hold_m_name=hold_m_name
             )
 
-            # 解析返回结果以获取order_code和order_id
-            result_data = json.loads(result) if isinstance(result, str) else result
-            order_code = result_data.get("order_code")
-            order_id = result_data.get("order_id")
-            order_params = result_data.get("order_params", {})
-
-            # 构建详细信息（保持原有结构）
-            detail = {
-                "index": 1,
-                "name": name,
+            summary = {
                 "success": True,
-                "order_code": order_code,
-                "order_id": order_id,
                 "hold_m_name": hold_m_name,
+                "material_name": name,
                 "90_vials": {
-                    "count": 1,
-                    "weight_per_vial": round(main_portion, 6),
+                    "count": 3,
+                    "weight_per_vial": round(portion_90, 6),
                     "total_weight": round(main_portion, 6)
                 },
                 "10_vials": {
                     "count": 1,
                     "solid_weight": round(titration_portion, 6),
                     "liquid_volume": round(titration_solvent, 6)
-                },
-                "order_params": order_params
-            }
-
-            # 构建批量结果格式（与diamine_solution_tasks保持一致）
-            summary = {
-                "total": 1,
-                "success": 1,
-                "failed": 0,
-                "order_codes": [order_code],
-                "order_ids": [order_id],
-                "details": [detail]
+                }
             }
 
             self.hardware_interface._logger.info(
-                f"成功创建90%10%小瓶投料任务: {name}, order_code={order_code}, order_id={order_id}"
+                f"成功创建90%10%小瓶投料任务: {hold_m_name}, "
+                f"90%物料={portion_90:.6f}g×3, 10%物料={titration_portion:.6f}g+{titration_solvent:.6f}mL"
             )
 
-            # 构建返回结果
-            summary["return_info"] = {
-                "order_codes": [order_code],
-                "order_ids": [order_id],
-            }
-
-            return summary
+            # 返回JSON字符串格式
+            return json.dumps(summary, ensure_ascii=False)
 
         except BioyondException:
             raise
@@ -780,279 +669,6 @@ class BioyondDispensingStation(BioyondWorkstation):
             raise BioyondException(error_msg)
 
 
-
-    def wait_for_multiple_orders_and_get_reports(self,
-                                                  batch_create_result: str = None,
-                                                  timeout: int = 7200,
-                                                  check_interval: int = 10) -> Dict[str, Any]:
-        """
-        同时等待多个任务完成并获取实验报告
-
-        参数说明:
-        - batch_create_result: 批量创建任务的返回结果JSON字符串，包含order_codes和order_ids数组
-        - timeout: 超时时间（秒），默认7200秒（2小时）
-        - check_interval: 检查间隔（秒），默认10秒
-
-        返回: 包含所有任务状态和报告的字典
-        {
-            "total": 2,
-            "completed": 2,
-            "timeout": 0,
-            "elapsed_time": 120.5,
-            "reports": [
-                {
-                    "order_code": "task_vial_1",
-                    "order_id": "uuid1",
-                    "status": "completed",
-                    "completion_status": 30,
-                    "report": {...}
-                },
-                ...
-            ]
-        }
-
-        异常:
-        - BioyondException: 所有任务都超时或发生错误
-        """
-        try:
-            # 参数类型转换
-            timeout = int(timeout) if timeout else 7200
-            check_interval = int(check_interval) if check_interval else 10
-
-            # 验证batch_create_result参数
-            if not batch_create_result or batch_create_result == "":
-                raise BioyondException("batch_create_result参数为空，请确保从batch_create节点正确连接handle")
-
-            # 解析batch_create_result JSON对象
-            try:
-                # 清理可能存在的截断标记 [...]
-                if isinstance(batch_create_result, str) and '[...]' in batch_create_result:
-                    batch_create_result = batch_create_result.replace('[...]', '[]')
-
-                result_obj = json.loads(batch_create_result) if isinstance(batch_create_result, str) else batch_create_result
-
-                # 兼容外层包装格式 {error, suc, return_value}
-                if isinstance(result_obj, dict) and "return_value" in result_obj:
-                    inner = result_obj.get("return_value")
-                    if isinstance(inner, str):
-                        result_obj = json.loads(inner)
-                    elif isinstance(inner, dict):
-                        result_obj = inner
-
-                # 从summary对象中提取order_codes和order_ids
-                order_codes = result_obj.get("order_codes", [])
-                order_ids = result_obj.get("order_ids", [])
-
-            except json.JSONDecodeError as e:
-                raise BioyondException(f"解析batch_create_result失败: {e}")
-            except Exception as e:
-                raise BioyondException(f"处理batch_create_result时出错: {e}")
-
-            # 验证提取的数据
-            if not order_codes:
-                raise BioyondException("batch_create_result中未找到order_codes字段或为空")
-            if not order_ids:
-                raise BioyondException("batch_create_result中未找到order_ids字段或为空")
-
-            # 确保order_codes和order_ids是列表类型
-            if not isinstance(order_codes, list):
-                order_codes = [order_codes] if order_codes else []
-            if not isinstance(order_ids, list):
-                order_ids = [order_ids] if order_ids else []
-
-            codes_list = order_codes
-            ids_list = order_ids
-
-            if len(codes_list) != len(ids_list):
-                raise BioyondException(
-                    f"order_codes数量({len(codes_list)})与order_ids数量({len(ids_list)})不匹配"
-                )
-
-            if not codes_list or not ids_list:
-                raise BioyondException("order_codes和order_ids不能为空")
-
-            # 初始化跟踪变量
-            total = len(codes_list)
-            pending_orders = {code: {"order_id": ids_list[i], "completed": False}
-                            for i, code in enumerate(codes_list)}
-            reports = []
-
-            start_time = time.time()
-            self.hardware_interface._logger.info(
-                f"开始等待 {total} 个任务完成: {', '.join(codes_list)}"
-            )
-
-            # 轮询检查任务状态
-            while pending_orders:
-                elapsed_time = time.time() - start_time
-
-                # 检查超时
-                if elapsed_time > timeout:
-                    # 收集超时任务
-                    timeout_orders = list(pending_orders.keys())
-                    self.hardware_interface._logger.error(
-                        f"等待任务完成超时，剩余未完成任务: {', '.join(timeout_orders)}"
-                    )
-
-                    # 为超时任务添加记录
-                    for order_code in timeout_orders:
-                        reports.append({
-                            "order_code": order_code,
-                            "order_id": pending_orders[order_code]["order_id"],
-                            "status": "timeout",
-                            "completion_status": None,
-                            "report": None,
-                            "elapsed_time": elapsed_time
-                        })
-
-                    break
-
-                # 检查每个待完成的任务
-                completed_in_this_round = []
-                for order_code in list(pending_orders.keys()):
-                    order_id = pending_orders[order_code]["order_id"]
-
-                    # 检查任务是否完成
-                    if order_code in self.order_completion_status:
-                        completion_info = self.order_completion_status[order_code]
-                        self.hardware_interface._logger.info(
-                            f"检测到任务 {order_code} 已完成，状态: {completion_info.get('status')}"
-                        )
-
-                        # 获取实验报告
-                        try:
-                            report_query = json.dumps({"order_id": order_id})
-                            report = self.hardware_interface.order_report(report_query)
-
-                            if not report:
-                                self.hardware_interface._logger.warning(
-                                    f"任务 {order_code} 已完成但无法获取报告"
-                                )
-                                report = {"error": "无法获取报告"}
-                            else:
-                                self.hardware_interface._logger.info(
-                                    f"成功获取任务 {order_code} 的实验报告"
-                                )
-
-                            reports.append({
-                                "order_code": order_code,
-                                "order_id": order_id,
-                                "status": "completed",
-                                "completion_status": completion_info.get('status'),
-                                "report": report,
-                                "elapsed_time": elapsed_time
-                            })
-
-                            # 标记为已完成
-                            completed_in_this_round.append(order_code)
-
-                            # 清理完成状态记录
-                            del self.order_completion_status[order_code]
-
-                        except Exception as e:
-                            self.hardware_interface._logger.error(
-                                f"查询任务 {order_code} 报告失败: {str(e)}"
-                            )
-                            reports.append({
-                                "order_code": order_code,
-                                "order_id": order_id,
-                                "status": "error",
-                                "completion_status": completion_info.get('status'),
-                                "report": None,
-                                "error": str(e),
-                                "elapsed_time": elapsed_time
-                            })
-                            completed_in_this_round.append(order_code)
-
-                # 从待完成列表中移除已完成的任务
-                for order_code in completed_in_this_round:
-                    del pending_orders[order_code]
-
-                # 如果还有待完成的任务，等待后继续
-                if pending_orders:
-                    time.sleep(check_interval)
-
-                    # 每分钟记录一次等待状态
-                    new_elapsed_time = time.time() - start_time
-                    if int(new_elapsed_time) % 60 == 0 and new_elapsed_time > 0:
-                        self.hardware_interface._logger.info(
-                            f"批量等待任务中... 已完成 {len(reports)}/{total}, "
-                            f"待完成: {', '.join(pending_orders.keys())}, "
-                            f"已等待 {int(new_elapsed_time/60)} 分钟"
-                        )
-
-            # 统计结果
-            completed_count = sum(1 for r in reports if r['status'] == 'completed')
-            timeout_count = sum(1 for r in reports if r['status'] == 'timeout')
-            error_count = sum(1 for r in reports if r['status'] == 'error')
-
-            final_elapsed_time = time.time() - start_time
-
-            summary = {
-                "total": total,
-                "completed": completed_count,
-                "timeout": timeout_count,
-                "error": error_count,
-                "elapsed_time": round(final_elapsed_time, 2),
-                "reports": reports
-            }
-
-            self.hardware_interface._logger.info(
-                f"批量等待任务完成: 总数={total}, 成功={completed_count}, "
-                f"超时={timeout_count}, 错误={error_count}, 耗时={final_elapsed_time:.1f}秒"
-            )
-
-            # 返回字典格式，在顶层包含统计信息
-            return {
-                "return_info": json.dumps(summary, ensure_ascii=False)
-            }
-
-        except BioyondException:
-            raise
-        except Exception as e:
-            error_msg = f"批量等待任务完成时发生未预期的错误: {str(e)}"
-            self.hardware_interface._logger.error(error_msg)
-            raise BioyondException(error_msg)
-
-    def process_order_finish_report(self, report_request, used_materials) -> Dict[str, Any]:
-        """
-        重写父类方法，处理任务完成报送并记录到 order_completion_status
-
-        Args:
-            report_request: WorkstationReportRequest 对象，包含任务完成信息
-            used_materials: 物料使用记录列表
-
-        Returns:
-            Dict[str, Any]: 处理结果
-        """
-        try:
-            # 调用父类方法
-            result = super().process_order_finish_report(report_request, used_materials)
-
-            # 记录任务完成状态
-            data = report_request.data
-            order_code = data.get('orderCode')
-
-            if order_code:
-                self.order_completion_status[order_code] = {
-                    'status': data.get('status'),
-                    'order_name': data.get('orderName'),
-                    'timestamp': datetime.now().isoformat(),
-                    'start_time': data.get('startTime'),
-                    'end_time': data.get('endTime')
-                }
-
-                self.hardware_interface._logger.info(
-                    f"已记录任务完成状态: {order_code}, status={data.get('status')}"
-                )
-
-            return result
-
-        except Exception as e:
-            self.hardware_interface._logger.error(f"处理任务完成报送失败: {e}")
-            return {"processed": False, "error": str(e)}
-
-
 if __name__ == "__main__":
     bioyond = BioyondDispensingStation(config={
         "api_key": "DE9BDDA0",
@@ -1473,3 +1089,4 @@ if __name__ == "__main__":
 
     # id = "3a1bce3c-4f31-c8f3-5525-f3b273bc34dc"
     # bioyond.sample_waste_removal(id)
+

unilabos/devices/workstation/bioyond_studio/reaction_station.py

@@ -1,11 +1,7 @@
 import json
-import time
 import requests
 from typing import List, Dict, Any
-from pathlib import Path
-from datetime import datetime
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
-from unilabos.ros.msgs.message_converter import convert_to_ros_msg, Float64, String
 from unilabos.devices.workstation.bioyond_studio.config import (
     WORKFLOW_STEP_IDS,
     WORKFLOW_TO_SECTION_MAP,
@@ -14,37 +10,6 @@ from unilabos.devices.workstation.bioyond_studio.config import (
 from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
 
 
-class BioyondReactor:
-    def __init__(self, config: dict = None, deck=None, protocol_type=None, **kwargs):
-        self.in_temperature = 0.0
-        self.out_temperature = 0.0
-        self.pt100_temperature = 0.0
-        self.sensor_average_temperature = 0.0
-        self.target_temperature = 0.0
-        self.setting_temperature = 0.0
-        self.viscosity = 0.0
-        self.average_viscosity = 0.0
-        self.speed = 0.0
-        self.force = 0.0
-
-    def update_metrics(self, payload: Dict[str, Any]):
-        def _f(v):
-            try:
-                return float(v)
-            except Exception:
-                return 0.0
-        self.target_temperature = _f(payload.get("targetTemperature"))
-        self.setting_temperature = _f(payload.get("settingTemperature"))
-        self.in_temperature = _f(payload.get("inTemperature"))
-        self.out_temperature = _f(payload.get("outTemperature"))
-        self.pt100_temperature = _f(payload.get("pt100Temperature"))
-        self.sensor_average_temperature = _f(payload.get("sensorAverageTemperature"))
-        self.speed = _f(payload.get("speed"))
-        self.force = _f(payload.get("force"))
-        self.viscosity = _f(payload.get("viscosity"))
-        self.average_viscosity = _f(payload.get("averageViscosity"))
-
-
 class BioyondReactionStation(BioyondWorkstation):
     """Bioyond反应站类
 
@@ -72,19 +37,6 @@ class BioyondReactionStation(BioyondWorkstation):
         print(f"BioyondReactionStation初始化完成 - workflow_mappings: {self.workflow_mappings}")
         print(f"workflow_mappings长度: {len(self.workflow_mappings)}")
 
-        self.in_temperature = 0.0
-        self.out_temperature = 0.0
-        self.pt100_temperature = 0.0
-        self.sensor_average_temperature = 0.0
-        self.target_temperature = 0.0
-        self.setting_temperature = 0.0
-        self.viscosity = 0.0
-        self.average_viscosity = 0.0
-        self.speed = 0.0
-        self.force = 0.0
-
-        self._frame_to_reactor_id = {1: "reactor_1", 2: "reactor_2", 3: "reactor_3", 4: "reactor_4", 5: "reactor_5"}
-
     # ==================== 工作流方法 ====================
 
     def reactor_taken_out(self):
@@ -280,7 +232,7 @@ class BioyondReactionStation(BioyondWorkstation):
             temperature: 温度设定(°C)
         """
         # 处理 volume 参数:优先使用直接传入的 volume,否则从 solvents 中提取
-        if not volume and solvents is not None:
+        if volume is None and solvents is not None:
             # 参数类型转换:如果是字符串则解析为字典
             if isinstance(solvents, str):
                 try:
@@ -339,39 +291,22 @@ class BioyondReactionStation(BioyondWorkstation):
 
     def liquid_feeding_titration(
         self,
+        volume_formula: str,
         assign_material_name: str,
-        volume_formula: str = None,
-        x_value: str = None,
-        feeding_order_data: str = None,
-        extracted_actuals: str = None,
-        titration_type: str = "2",
+        titration_type: str = "1",
         time: str = "90",
         torque_variation: int = 2,
         temperature: float = 25.00
     ):
         """液体进料(滴定)
 
-        支持两种模式:
-        1. 直接提供 volume_formula (传统方式)
-        2. 自动计算公式: 提供 x_value, feeding_order_data, extracted_actuals (新方式)
-
         Args:
+            volume_formula: 分液公式(μL)
             assign_material_name: 物料名称
-            volume_formula: 分液公式(μL),如果提供则直接使用,否则自动计算
-            x_value: 手工输入的x值,格式如 "1-2-3"
-            feeding_order_data: feeding_order JSON字符串或对象,用于获取m二酐值
-            extracted_actuals: 从报告提取的实际加料量JSON字符串,包含actualTargetWeigh和actualVolume
-            titration_type: 是否滴定(1=否, 2=是),默认2
+            titration_type: 是否滴定(1=否, 2=是)
             time: 观察时间(分钟)
             torque_variation: 是否观察(int类型, 1=否, 2=是)
             temperature: 温度(°C)
-
-        自动公式模板: 1000*(m二酐-x)*V二酐滴定/m二酐滴定
-        其中:
-        - m二酐滴定 = actualTargetWeigh (从extracted_actuals获取)
-        - V二酐滴定 = actualVolume (从extracted_actuals获取)
-        - x = x_value (手工输入)
-        - m二酐 = feeding_order中type为"main_anhydride"的amount值
         """
         self.append_to_workflow_sequence('{"web_workflow_name": "Liquid_feeding(titration)"}')
         material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
@@ -381,84 +316,6 @@ class BioyondReactionStation(BioyondWorkstation):
         if isinstance(temperature, str):
             temperature = float(temperature)
 
-        # 如果没有直接提供volume_formula,则自动计算
-        if not volume_formula and x_value and feeding_order_data and extracted_actuals:
-            # 1. 解析 feeding_order_data 获取 m二酐
-            if isinstance(feeding_order_data, str):
-                try:
-                    feeding_order_data = json.loads(feeding_order_data)
-                except json.JSONDecodeError as e:
-                    raise ValueError(f"feeding_order_data JSON解析失败: {str(e)}")
-
-            # 支持两种格式:
-            # 格式1: 直接是数组 [{...}, {...}]
-            # 格式2: 对象包裹 {"feeding_order": [{...}, {...}]}
-            if isinstance(feeding_order_data, list):
-                feeding_order_list = feeding_order_data
-            elif isinstance(feeding_order_data, dict):
-                feeding_order_list = feeding_order_data.get("feeding_order", [])
-            else:
-                raise ValueError("feeding_order_data 必须是数组或包含feeding_order的字典")
-
-            # 从feeding_order中找到main_anhydride的amount
-            m_anhydride = None
-            for item in feeding_order_list:
-                if item.get("type") == "main_anhydride":
-                    m_anhydride = item.get("amount")
-                    break
-
-            if m_anhydride is None:
-                raise ValueError("在feeding_order中未找到type为'main_anhydride'的条目")
-
-            # 2. 解析 extracted_actuals 获取 actualTargetWeigh 和 actualVolume
-            if isinstance(extracted_actuals, str):
-                try:
-                    extracted_actuals_obj = json.loads(extracted_actuals)
-                except json.JSONDecodeError as e:
-                    raise ValueError(f"extracted_actuals JSON解析失败: {str(e)}")
-            else:
-                extracted_actuals_obj = extracted_actuals
-
-            # 获取actuals数组
-            actuals_list = extracted_actuals_obj.get("actuals", [])
-            if not actuals_list:
-                # actuals为空,无法自动生成公式,回退到手动模式
-                print(f"警告: extracted_actuals中actuals数组为空,无法自动生成公式,请手动提供volume_formula")
-                volume_formula = None  # 清空,触发后续的错误检查
-            else:
-                # 根据assign_material_name匹配对应的actual数据
-                # 假设order_code中包含物料名称
-                matched_actual = None
-                for actual in actuals_list:
-                    order_code = actual.get("order_code", "")
-                    # 简单匹配:如果order_code包含物料名称
-                    if assign_material_name in order_code:
-                        matched_actual = actual
-                        break
-
-                # 如果没有匹配到,使用第一个
-                if not matched_actual and actuals_list:
-                    matched_actual = actuals_list[0]
-
-                if not matched_actual:
-                    raise ValueError("无法从extracted_actuals中获取实际加料量数据")
-
-                m_anhydride_titration = matched_actual.get("actualTargetWeigh")  # m二酐滴定
-                v_anhydride_titration = matched_actual.get("actualVolume")       # V二酐滴定
-
-                if m_anhydride_titration is None or v_anhydride_titration is None:
-                    raise ValueError(f"实际加料量数据不完整: actualTargetWeigh={m_anhydride_titration}, actualVolume={v_anhydride_titration}")
-
-                # 3. 构建公式: 1000*(m二酐-x)*V二酐滴定/m二酐滴定
-                # x_value 格式如 "{{1-2-3}}",保留完整格式(包括花括号)直接替换到公式中
-                volume_formula = f"1000*({m_anhydride}-{x_value})*{v_anhydride_titration}/{m_anhydride_titration}"
-
-                print(f"自动生成滴定公式: {volume_formula}")
-                print(f"  m二酐={m_anhydride}, x={x_value}, V二酐滴定={v_anhydride_titration}, m二酐滴定={m_anhydride_titration}")
-
-        elif not volume_formula:
-            raise ValueError("必须提供 volume_formula 或 (x_value + feeding_order_data + extracted_actuals)")
-
         liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["liquid"]
         observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["observe"]
 
@@ -486,289 +343,9 @@ class BioyondReactionStation(BioyondWorkstation):
         print(f"当前队列长度: {len(self.pending_task_params)}")
         return json.dumps({"suc": True})
 
-    def _extract_actuals_from_report(self, report) -> Dict[str, Any]:
-        data = report.get('data') if isinstance(report, dict) else None
-        actual_target_weigh = None
-        actual_volume = None
-        if data:
-            extra = data.get('extraProperties') or {}
-            if isinstance(extra, dict):
-                for v in extra.values():
-                    obj = None
-                    try:
-                        obj = json.loads(v) if isinstance(v, str) else v
-                    except Exception:
-                        obj = None
-                    if isinstance(obj, dict):
-                        tw = obj.get('targetWeigh')
-                        vol = obj.get('volume')
-                        if tw is not None:
-                            try:
-                                actual_target_weigh = float(tw)
-                            except Exception:
-                                pass
-                        if vol is not None:
-                            try:
-                                actual_volume = float(vol)
-                            except Exception:
-                                pass
-        return {
-            'actualTargetWeigh': actual_target_weigh,
-            'actualVolume': actual_volume
-        }
-
-    def extract_actuals_from_batch_reports(self, batch_reports_result: str) -> dict:
-        print(f"[DEBUG] extract_actuals 收到原始数据: {batch_reports_result[:500]}...")  # 打印前500字符
-        try:
-            obj = json.loads(batch_reports_result) if isinstance(batch_reports_result, str) else batch_reports_result
-            if isinstance(obj, dict) and "return_info" in obj:
-                inner = obj["return_info"]
-                obj = json.loads(inner) if isinstance(inner, str) else inner
-            reports = obj.get("reports", []) if isinstance(obj, dict) else []
-            print(f"[DEBUG] 解析后的 reports 数组长度: {len(reports)}")
-        except Exception as e:
-            print(f"[DEBUG] 解析异常: {e}")
-            reports = []
-
-        actuals = []
-        for i, r in enumerate(reports):
-            print(f"[DEBUG] 处理 report[{i}]: order_code={r.get('order_code')}, has_extracted={r.get('extracted') is not None}, has_report={r.get('report') is not None}")
-            order_code = r.get("order_code")
-            order_id = r.get("order_id")
-            ex = r.get("extracted")
-            if isinstance(ex, dict) and (ex.get("actualTargetWeigh") is not None or ex.get("actualVolume") is not None):
-                print(f"[DEBUG] 从 extracted 字段提取: actualTargetWeigh={ex.get('actualTargetWeigh')}, actualVolume={ex.get('actualVolume')}")
-                actuals.append({
-                    "order_code": order_code,
-                    "order_id": order_id,
-                    "actualTargetWeigh": ex.get("actualTargetWeigh"),
-                    "actualVolume": ex.get("actualVolume")
-                })
-                continue
-            report = r.get("report")
-            vals = self._extract_actuals_from_report(report) if report else {"actualTargetWeigh": None, "actualVolume": None}
-            print(f"[DEBUG] 从 report 字段提取: {vals}")
-            actuals.append({
-                "order_code": order_code,
-                "order_id": order_id,
-                **vals
-            })
-
-        print(f"[DEBUG] 最终提取的 actuals 数组长度: {len(actuals)}")
-        result = {
-            "return_info": json.dumps({"actuals": actuals}, ensure_ascii=False)
-        }
-        print(f"[DEBUG] 返回结果: {result}")
-        return result
-
-    def process_temperature_cutoff_report(self, report_request) -> Dict[str, Any]:
-        try:
-            data = report_request.data
-            def _f(v):
-                try:
-                    return float(v)
-                except Exception:
-                    return 0.0
-            self.target_temperature = _f(data.get("targetTemperature"))
-            self.setting_temperature = _f(data.get("settingTemperature"))
-            self.in_temperature = _f(data.get("inTemperature"))
-            self.out_temperature = _f(data.get("outTemperature"))
-            self.pt100_temperature = _f(data.get("pt100Temperature"))
-            self.sensor_average_temperature = _f(data.get("sensorAverageTemperature"))
-            self.speed = _f(data.get("speed"))
-            self.force = _f(data.get("force"))
-            self.viscosity = _f(data.get("viscosity"))
-            self.average_viscosity = _f(data.get("averageViscosity"))
-
-            try:
-                if hasattr(self, "_ros_node") and self._ros_node is not None:
-                    props = [
-                        "in_temperature","out_temperature","pt100_temperature","sensor_average_temperature",
-                        "target_temperature","setting_temperature","viscosity","average_viscosity",
-                        "speed","force"
-                    ]
-                    for name in props:
-                        pub = self._ros_node._property_publishers.get(name)
-                        if pub:
-                            pub.publish_property()
-                    frame = data.get("frameCode")
-                    reactor_id = None
-                    try:
-                        reactor_id = self._frame_to_reactor_id.get(int(frame))
-                    except Exception:
-                        reactor_id = None
-                    if reactor_id and hasattr(self._ros_node, "sub_devices"):
-                        child = self._ros_node.sub_devices.get(reactor_id)
-                        if child and hasattr(child, "driver_instance"):
-                            child.driver_instance.update_metrics(data)
-                            pubs = getattr(child.ros_node_instance, "_property_publishers", {})
-                            for name in props:
-                                p = pubs.get(name)
-                                if p:
-                                    p.publish_property()
-            except Exception:
-                pass
-            event = {
-                "frameCode": data.get("frameCode"),
-                "generateTime": data.get("generateTime"),
-                "targetTemperature": data.get("targetTemperature"),
-                "settingTemperature": data.get("settingTemperature"),
-                "inTemperature": data.get("inTemperature"),
-                "outTemperature": data.get("outTemperature"),
-                "pt100Temperature": data.get("pt100Temperature"),
-                "sensorAverageTemperature": data.get("sensorAverageTemperature"),
-                "speed": data.get("speed"),
-                "force": data.get("force"),
-                "viscosity": data.get("viscosity"),
-                "averageViscosity": data.get("averageViscosity"),
-                "request_time": report_request.request_time,
-                "timestamp": datetime.now().isoformat(),
-                "reactor_id": self._frame_to_reactor_id.get(int(data.get("frameCode", 0))) if str(data.get("frameCode", "")).isdigit() else None,
-            }
-
-            base_dir = Path(__file__).resolve().parents[3] / "unilabos_data"
-            base_dir.mkdir(parents=True, exist_ok=True)
-            out_file = base_dir / "temperature_cutoff_events.json"
-            try:
-                existing = json.loads(out_file.read_text(encoding="utf-8")) if out_file.exists() else []
-                if not isinstance(existing, list):
-                    existing = []
-            except Exception:
-                existing = []
-            existing.append(event)
-            out_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2), encoding="utf-8")
-
-            if hasattr(self, "_ros_node") and self._ros_node is not None:
-                ns = self._ros_node.namespace
-                topics = {
-                    "targetTemperature": f"{ns}/metrics/temperature_cutoff/target_temperature",
-                    "settingTemperature": f"{ns}/metrics/temperature_cutoff/setting_temperature",
-                    "inTemperature": f"{ns}/metrics/temperature_cutoff/in_temperature",
-                    "outTemperature": f"{ns}/metrics/temperature_cutoff/out_temperature",
-                    "pt100Temperature": f"{ns}/metrics/temperature_cutoff/pt100_temperature",
-                    "sensorAverageTemperature": f"{ns}/metrics/temperature_cutoff/sensor_average_temperature",
-                    "speed": f"{ns}/metrics/temperature_cutoff/speed",
-                    "force": f"{ns}/metrics/temperature_cutoff/force",
-                    "viscosity": f"{ns}/metrics/temperature_cutoff/viscosity",
-                    "averageViscosity": f"{ns}/metrics/temperature_cutoff/average_viscosity",
-                }
-                for k, t in topics.items():
-                    v = data.get(k)
-                    if v is not None:
-                        pub = self._ros_node.create_publisher(Float64, t, 10)
-                        pub.publish(convert_to_ros_msg(Float64, float(v)))
-
-                evt_pub = self._ros_node.create_publisher(String, f"{ns}/events/temperature_cutoff", 10)
-                evt_pub.publish(convert_to_ros_msg(String, json.dumps(event, ensure_ascii=False)))
-
-            return {"processed": True, "frame": data.get("frameCode")}
-        except Exception as e:
-            return {"processed": False, "error": str(e)}
-
-    def wait_for_multiple_orders_and_get_reports(self, batch_create_result: str = None, timeout: int = 7200, check_interval: int = 10) -> Dict[str, Any]:
-        try:
-            timeout = int(timeout) if timeout else 7200
-            check_interval = int(check_interval) if check_interval else 10
-            if not batch_create_result or batch_create_result == "":
-                raise ValueError("batch_create_result为空")
-            try:
-                if isinstance(batch_create_result, str) and '[...]' in batch_create_result:
-                    batch_create_result = batch_create_result.replace('[...]', '[]')
-                result_obj = json.loads(batch_create_result) if isinstance(batch_create_result, str) else batch_create_result
-                if isinstance(result_obj, dict) and "return_value" in result_obj:
-                    inner = result_obj.get("return_value")
-                    if isinstance(inner, str):
-                        result_obj = json.loads(inner)
-                    elif isinstance(inner, dict):
-                        result_obj = inner
-                order_codes = result_obj.get("order_codes", [])
-                order_ids = result_obj.get("order_ids", [])
-            except Exception as e:
-                raise ValueError(f"解析batch_create_result失败: {e}")
-            if not order_codes or not order_ids:
-                raise ValueError("缺少order_codes或order_ids")
-            if not isinstance(order_codes, list):
-                order_codes = [order_codes]
-            if not isinstance(order_ids, list):
-                order_ids = [order_ids]
-            if len(order_codes) != len(order_ids):
-                raise ValueError("order_codes与order_ids数量不匹配")
-            total = len(order_codes)
-            pending = {c: {"order_id": order_ids[i], "completed": False} for i, c in enumerate(order_codes)}
-            reports = []
-            start_time = time.time()
-            while pending:
-                elapsed_time = time.time() - start_time
-                if elapsed_time > timeout:
-                    for oc in list(pending.keys()):
-                        reports.append({
-                            "order_code": oc,
-                            "order_id": pending[oc]["order_id"],
-                            "status": "timeout",
-                            "completion_status": None,
-                            "report": None,
-                            "extracted": None,
-                            "elapsed_time": elapsed_time
-                        })
-                    break
-                completed_round = []
-                for oc in list(pending.keys()):
-                    oid = pending[oc]["order_id"]
-                    if oc in self.order_completion_status:
-                        info = self.order_completion_status[oc]
-                        try:
-                            rq = json.dumps({"order_id": oid})
-                            rep = self.hardware_interface.order_report(rq)
-                            if not rep:
-                                rep = {"error": "无法获取报告"}
-                            reports.append({
-                                "order_code": oc,
-                                "order_id": oid,
-                                "status": "completed",
-                                "completion_status": info.get('status'),
-                                "report": rep,
-                                "extracted": self._extract_actuals_from_report(rep),
-                                "elapsed_time": elapsed_time
-                            })
-                            completed_round.append(oc)
-                            del self.order_completion_status[oc]
-                        except Exception as e:
-                            reports.append({
-                                "order_code": oc,
-                                "order_id": oid,
-                                "status": "error",
-                                "completion_status": info.get('status') if 'info' in locals() else None,
-                                "report": None,
-                                "extracted": None,
-                                "error": str(e),
-                                "elapsed_time": elapsed_time
-                            })
-                            completed_round.append(oc)
-                for oc in completed_round:
-                    del pending[oc]
-                if pending:
-                    time.sleep(check_interval)
-            completed_count = sum(1 for r in reports if r['status'] == 'completed')
-            timeout_count = sum(1 for r in reports if r['status'] == 'timeout')
-            error_count = sum(1 for r in reports if r['status'] == 'error')
-            final_elapsed_time = time.time() - start_time
-            summary = {
-                "total": total,
-                "completed": completed_count,
-                "timeout": timeout_count,
-                "error": error_count,
-                "elapsed_time": round(final_elapsed_time, 2),
-                "reports": reports
-            }
-            return {
-                "return_info": json.dumps(summary, ensure_ascii=False)
-            }
-        except Exception as e:
-            raise
-
     def liquid_feeding_beaker(
         self,
-        volume: str = "350",
+        volume: str = "35000",
         assign_material_name: str = "BAPP",
         time: str = "0",
         torque_variation: int = 1,
@@ -778,7 +355,7 @@ class BioyondReactionStation(BioyondWorkstation):
         """液体进料烧杯
 
         Args:
-            volume: 分液质量(g)
+            volume: 分液量(μL)
             assign_material_name: 物料名称(试剂瓶位)
             time: 观察时间(分钟)
             torque_variation: 是否观察(int类型, 1=否, 2=是)
@@ -1003,14 +580,7 @@ class BioyondReactionStation(BioyondWorkstation):
         # print(f"\n✅ 任务创建成功: {result}")
         # print(f"\n✅ 任务创建成功")
         print(f"{'='*60}\n")
-
-        # 返回结果，包含合并后的工作流数据和订单参数
-        return json.dumps({
-            "success": True,
-            "result": result,
-            "merged_workflow": merged_workflow,
-            "order_params": order_params
-        })
+        return json.dumps({"success": True, "result": result})
 
     def _build_workflows_with_parameters(self, workflows_result: list) -> list:
         """
@@ -1210,4 +780,4 @@ class BioyondReactionStation(BioyondWorkstation):
         except Exception as e:
             print(f"   ❌ 工作流ID验证失败: {e}")
             print(f"   💡 将重新合并工作流")
-            return False
+            return False

unilabos/devices/workstation/coin_cell_assembly/Modbus_CSV_Mapping_Guide.md

@@ -0,0 +1,84 @@
+# Modbus CSV 地址映射说明
+
+本文档说明 `coin_cell_assembly_a.csv` 文件如何将命名节点映射到实际的 Modbus 地址，以及如何在代码中使用它们。
+
+## 1. CSV 文件结构
+
+地址表文件位于同级目录下：`coin_cell_assembly_a.csv`
+
+每一行定义了一个 Modbus 节点，包含以下关键列：
+
+| 列名 | 说明 | 示例 |
+|------|------|------|
+| **Name** | **节点名称** (代码中引用的 Key) | `COIL_ALUMINUM_FOIL` |
+| **DataType** | 数据类型 (BOOL, INT16, FLOAT32, STRING) | `BOOL` |
+| **Comment** | 注释说明 | `使用铝箔垫` |
+| **Attribute** | 属性 (通常留空或用于额外标记) | |
+| **DeviceType** | Modbus 寄存器类型 (`coil`, `hold_register`) | `coil` |
+| **Address** | **Modbus 地址** (十进制) | `8340` |
+
+### 示例行 (铝箔垫片)
+
+```csv
+COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,8340,
+```
+
+- **名称**: `COIL_ALUMINUM_FOIL`
+- **类型**: `coil` (线圈，读写单个位)
+- **地址**: `8340`
+
+---
+
+## 2. 加载与注册流程
+
+在 `coin_cell_assembly.py` 的初始化代码中：
+
+1. **加载 CSV**: `BaseClient.load_csv()` 读取 CSV 并解析每行定义。
+2. **注册节点**: `modbus_client.register_node_list()` 将解析后的节点注册到 Modbus 客户端实例中。
+
+```python
+# 代码位置: coin_cell_assembly.py (L174-175)
+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)
+```
+
+---
+
+## 3. 代码中的使用方式
+
+注册后，通过 `self.client.use_node('节点名称')` 即可获取该节点对象并进行读写操作，无需关心具体地址。
+
+### 控制铝箔垫片 (COIL_ALUMINUM_FOIL)
+
+```python
+# 代码位置: qiming_coin_cell_code 函数 (L1048)
+self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian)
+```
+
+- **写入 True**: 对应 Modbus 功能码 05 (Write Single Coil)，向地址 `8340` 写入 `1` (ON)。
+- **写入 False**: 向地址 `8340` 写入 `0` (OFF)。
+
+> **注意**: 代码中使用了 `not lvbodian`，这意味着逻辑是反转的。如果 `lvbodian` 参数为 `True` (默认)，写入的是 `False` (不使用铝箔垫)。
+
+---
+
+## 4. 地址转换注意事项 (Modbus vs PLC)
+
+CSV 中的 `Address` 列（如 `8340`）是 **Modbus 协议地址**。
+
+如果使用 InoProShop (汇川 PLC 编程软件)，看到的可能是 **PLC 内部地址** (如 `%QX...` 或 `%MW...`)。这两者之间通常需要转换。
+
+### 常见的转换规则 (示例)
+
+- **Coil (线圈) %QX**: 
+  - `Modbus地址 = 字节地址 * 8 + 位偏移`
+  - *例子*: `%QX834.0` -> `834 * 8 + 0` = `6672`
+  - *注意*: 如果 CSV 中配置的是 `8340`，这可能是一个自定义映射，或者是基于不同规则（如直接对应 Word 地址的某种映射，或者可能就是地址写错了/使用了非标准映射）。
+
+- **Register (寄存器) %MW**:
+  - 通常直接对应，或者有偏移量 (如 Modbus 40001 = PLC MW0)。
+
+### 验证方法
+由于 `test_unilab_interact.py` 中发现 `8450` (CSV风格) 不工作，而 `6760` (%QX845.0 计算值) 工作正常，**建议对 CSV 中的其他地址也进行核实**，特别是像 `8340` 这样以 0 结尾看起来像是 "字节地址+0" 的数值，可能实际上应该是 `%QX834.0` 对应的 `6672`。
+
+如果发现设备控制无反应，请尝试按照标准的 Modbus 计算方式转换 PLC 地址。

unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py

@@ -0,0 +1,645 @@
+"""
+纽扣电池组装工作站物料类定义
+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))
+
+
+def YH_Deck(name=""):
+    cd = CoincellDeck(name=name)
+    cd.setup()
+    return cd
+
+
+if __name__ == "__main__":
+    deck = create_coin_cell_deck()
+    print(deck)

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_1223.csv

@@ -0,0 +1,159 @@
+Name,DataType,Comment,DeviceType,Address,,
+COIL_SYS_START_CMD,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8010,,
+COIL_SYS_STOP_CMD,BOOL,<EFBFBD>豸ֹͣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8020,,
+COIL_SYS_RESET_CMD,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8030,,
+COIL_SYS_HAND_CMD,BOOL,<EFBFBD>豸<EFBFBD>ֶ<EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8040,,
+COIL_SYS_AUTO_CMD,BOOL,<EFBFBD>豸<EFBFBD>Զ<EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8050,,
+COIL_SYS_INIT_CMD,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8060,,
+COIL_SYS_STOP_STATUS,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD>ͣ<EFBFBD><EFBFBD>,coil,8220,,
+,,,,,,
+,BOOL,UNILAB<EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8720,,
+,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܵ<EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD>,coil,8520,,
+REG_MSG_ELECTROLYTE_NUM,WORD,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һʹ<EFBFBD><EFBFBD>ƿ<EFBFBD><EFBFBD>,hold_register,496,,
+,WORD,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD>̾<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,440,,
+,WORD,<EFBFBD><EFBFBD>Ĥ<EFBFBD>̾<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,450,,
+,WORD,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD>_<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ͼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,460,,
+,WORD,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD>_<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>վ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,430,,
+,WORD,g_<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD>_<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>޸˸׾<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,470,,
+,WORD,<EFBFBD><EFBFBD>Һǹͷ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼλ0<EFBFBD><EFBFBD>,hold_register,480,,
+,WORD,<EFBFBD><EFBFBD><EFBFBD>ø<EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,443,,
+,WORD,<EFBFBD><EFBFBD><EFBFBD>ø<EFBFBD>Ĥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,453,,
+,,,,,,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,UNILAB<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䷽<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8700,,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䷽,coil,8500,,
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,<EFBFBD><EFBFBD>ƿ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һʹ<EFBFBD>ô<EFBFBD><EFBFBD><EFBFBD>,hold_register,11000,,
+REG_MSG_ELECTROLYTE_VOLUME,INT16,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>ȡ<EFBFBD><EFBFBD>,hold_register,11004,,
+REG_MSG_ASSEMBLY_PRESSURE,INT16,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,11008,,
+REG_DATA_ELECTROLYTE_CODE,STRING,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>ά<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>к<EFBFBD>,hold_register,10020,,
+,BOOL,<EFBFBD>Ӿ<EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8300,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD>죨false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8310,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>_<EFBFBD><EFBFBD><EFBFBD>֣<EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8320,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>_<EFBFBD>Ҳ֣<EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8420,,
+,BOOL,<EFBFBD><EFBFBD>е<EFBFBD>ְ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̣<EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8330,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8340,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD>֪<EFBFBD><EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8350,,
+,BOOL,ѹ<EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD>false:ѹ<><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<C4A3><CABD>True:<3A><><EFBFBD><EFBFBD>ģʽ<C4A3><CABD>,coil,8360,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD>false:<3A><><EFBFBD>ε<EFBFBD>Һ<EFBFBD><D2BA>true:<3A><><EFBFBD>ε<EFBFBD>Һ<EFBFBD><D2BA>,coil,8370,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8380,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD>ʽ<EFBFBD><EFBFBD>false:<3A><>װ<EFBFBD><D7B0>true:<3A><>װ<EFBFBD><D7B0>,coil,8390,,
+,BOOL,ѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ࣨfalse:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8400,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD><EFBFBD>̷<EFBFBD>ʽ<EFBFBD><EFBFBD>false:ˮƽ<CBAE><C6BD><EFBFBD>̣<EFBFBD>true:<3A>ѵ<EFBFBD><D1B5><EFBFBD><EFBFBD>̣<EFBFBD>,coil,8410,,
+COIL_SYS_UNILAB_INTERACT ,BOOL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Unilab<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>false:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,coil,8450,,
+,BOOL,<EFBFBD><EFBFBD><EFBFBD>Ե<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ࣨfalse:ʹ<>ã<EFBFBD>true:<3A><><EFBFBD>ԣ<EFBFBD>,colil,8460,,
+,,,,,,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,UNILAB<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䷽<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8510,,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,UNILAB<EFBFBD><EFBFBD><EFBFBD>ܲ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,8710,,
+REG_DATA_POLE_WEIGHT,FLOAT32,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10010,,
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װʱ<EFBFBD><EFBFBD>,hold_register,10012,,
+REG_DATA_ASSEMBLY_PRESSURE,INT16,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10014,,
+REG_DATA_ELECTROLYTE_VOLUME,INT16,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>ע<EFBFBD><EFBFBD>,hold_register,10016,,
+REG_DATA_ASSEMBLY_TYPE,INT16,<EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD>ѵ<EFBFBD><EFBFBD><EFBFBD>ʽ(7/8),hold_register,10018,,
+REG_DATA_ELECTROLYTE_CODE,STRING,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>ά<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>к<EFBFBD>,hold_register,10020,,
+REG_DATA_COIN_CELL_CODE,STRING,<EFBFBD><EFBFBD><EFBFBD>ض<EFBFBD>ά<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>к<EFBFBD>,hold_register,10030,,
+REG_DATA_STACK_VISON_CODE,STRING,<EFBFBD><EFBFBD><EFBFBD>϶ѵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼƬ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10040,,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,<EFBFBD><EFBFBD>ǰ<EFBFBD>缫Һ<EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10000,,
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10002,,
+,INT,<EFBFBD><EFBFBD>е<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><EFBFBD><EFBFBD>ϼĴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1-<2D><><EFBFBD><EFBFBD><EFBFBD>ǡ<EFBFBD>2-<2D><><EFBFBD>桢3-<2D><><EFBFBD><EFBFBD>Ƭ<EFBFBD><C6AC>4-<2D><>Ĥ<EFBFBD><C4A4>5-<2D><><EFBFBD><EFBFBD>Ƭ<EFBFBD><C6AC>6-ƽ<>桢7-<2D><><EFBFBD>桢8-<2D><><EFBFBD><EFBFBD><EFBFBD>ǣ<EFBFBD>,hold_register,10060,,
+,,,,,,
+,INT,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10062,PLC<EFBFBD><EFBFBD>ַ,1223-<2D><><EFBFBD><EFBFBD>
+,INT,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD>Ĥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10064,,
+,INT,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ״̬<EFBFBD>루R<EFBFBD><EFBFBD>,hold_register,10066,,
+,REAL,<EFBFBD><EFBFBD>·<EFBFBD><EFBFBD>ѹOK<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10068,,
+,REAL,<EFBFBD><EFBFBD>·<EFBFBD><EFBFBD>ѹOK<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10070,,
+,INT,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10072,,
+,INT,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,10074,,
+,REAL,10mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,520,HMI<EFBFBD><EFBFBD>ַ,
+,REAL,12mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,522,,
+,REAL,16mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,524,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,526,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,528,,
+,REAL,ƽ<EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,530,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,532,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,534,,
+,REAL,<EFBFBD><EFBFBD>Ʒ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,536,,
+,REAL,<EFBFBD><EFBFBD>Ʒ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>NG<EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD><EFBFBD>,hold_register,538,,
+,,,,,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>10mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,540,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>12mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,542,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>16mm<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,544,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,546,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ǻ<EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,548,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,550,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD>ø<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ǻ<EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,552,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD>õ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,554,,
+,REAL,<EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD>Ʒ<EFBFBD><EFBFBD><EFBFBD>غ<EFBFBD><EFBFBD>ȣ<EFBFBD>W<EFBFBD><EFBFBD>,hold_register,556,,
+,,,,,,
+,,,,,,
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ѹ<EFBFBD><EFBFBD>,hold_register,10050,,
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˮ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10052,,
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,hold_register,10054,,
+,,,,,,
+,BOOL,<EFBFBD>쳣100-ϵͳ<CFB5>쳣,coil,1000,,
+,BOOL,<EFBFBD>쳣101-<2D><>ͣ,coil,1010,,
+,BOOL,<EFBFBD>쳣111-<2D><><EFBFBD><EFBFBD><EFBFBD>伱ͣ,coil,1110,,
+,BOOL,<EFBFBD>쳣112-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڹ<EFBFBD>դ<EFBFBD>ڵ<EFBFBD>,coil,1120,,
+,BOOL,<EFBFBD>쳣160-<2D><>Һǹͷȱ<CDB7><C8B1>,coil,1600,,
+,BOOL,<EFBFBD>쳣161-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȱ<EFBFBD><C8B1>,coil,1610,,
+,BOOL,<EFBFBD>쳣162-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȱ<EFBFBD><C8B1>,coil,1620,,
+,BOOL,<EFBFBD>쳣163-<2D><><EFBFBD><EFBFBD>Ƭȱ<C6AC><C8B1>,coil,1630,,
+,BOOL,<EFBFBD>쳣164-<2D><>Ĥȱ<C4A4><C8B1>,coil,1640,,
+,BOOL,<EFBFBD>쳣165-<2D><><EFBFBD><EFBFBD>Ƭȱ<C6AC><C8B1>,coil,1650,,
+,BOOL,<EFBFBD>쳣166-ƽ<><C6BD>ȱ<EFBFBD><C8B1>,coil,1660,,
+,BOOL,<EFBFBD>쳣167-<2D><><EFBFBD><EFBFBD>ȱ<EFBFBD><C8B1>,coil,1670,,
+,BOOL,<EFBFBD>쳣168-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȱ<EFBFBD><C8B1>,coil,1680,,
+,BOOL,<EFBFBD>쳣169-<2D><>Ʒ<EFBFBD><C6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,1690,,
+,BOOL,<EFBFBD>쳣201-<2D>ŷ<EFBFBD><C5B7><EFBFBD>01<30>쳣,coil,2010,,
+,BOOL,<EFBFBD>쳣202-<2D>ŷ<EFBFBD><C5B7><EFBFBD>02<30>쳣,coil,2020,,
+,BOOL,<EFBFBD>쳣203-<2D>ŷ<EFBFBD><C5B7><EFBFBD>03<30>쳣,coil,2030,,
+,BOOL,<EFBFBD>쳣204-<2D>ŷ<EFBFBD><C5B7><EFBFBD>04<30>쳣,coil,2040,,
+,BOOL,<EFBFBD>쳣205-<2D>ŷ<EFBFBD><C5B7><EFBFBD>05<30>쳣,coil,2050,,
+,BOOL,<EFBFBD>쳣206-<2D>ŷ<EFBFBD><C5B7><EFBFBD>06<30>쳣,coil,2060,,
+,BOOL,<EFBFBD>쳣207-<2D>ŷ<EFBFBD><C5B7><EFBFBD>07<30>쳣,coil,2070,,
+,BOOL,<EFBFBD>쳣208-<2D>ŷ<EFBFBD><C5B7><EFBFBD>08<30>쳣,coil,2080,,
+,BOOL,<EFBFBD>쳣209-<2D>ŷ<EFBFBD><C5B7><EFBFBD>09<30>쳣,coil,2090,,
+,BOOL,<EFBFBD>쳣210-<2D>ŷ<EFBFBD><C5B7><EFBFBD>10<31>쳣,coil,2100,,
+,BOOL,<EFBFBD>쳣211-<2D>ŷ<EFBFBD><C5B7><EFBFBD>11<31>쳣,coil,2110,,
+,BOOL,<EFBFBD>쳣212-<2D>ŷ<EFBFBD><C5B7><EFBFBD>12<31>쳣,coil,2120,,
+,BOOL,<EFBFBD>쳣213-<2D>ŷ<EFBFBD><C5B7><EFBFBD>13<31>쳣,coil,2130,,
+,BOOL,<EFBFBD>쳣214-<2D>ŷ<EFBFBD><C5B7><EFBFBD>14<31>쳣,coil,2140,,
+,BOOL,<EFBFBD>쳣250-<2D><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD>쳣,coil,2500,,
+,BOOL,<EFBFBD>쳣251-<2D><>ҺǹͨѶ<CDA8>쳣,coil,2510,,
+,BOOL,<EFBFBD>쳣252-<2D><>Һǹ<D2BA><C7B9><EFBFBD><EFBFBD>,coil,2520,,
+,BOOL,<EFBFBD>쳣256-<2D><>צ<EFBFBD>쳣,coil,2560,,
+,BOOL,<EFBFBD>쳣262-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>δ֪<CEB4><D6AA>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>,coil,2620,,
+,BOOL,<EFBFBD>쳣263-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>X<EFBFBD><58>Y<EFBFBD><59>Z<EFBFBD><5A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,2630,,
+,BOOL,<EFBFBD>쳣264-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӿ<EFBFBD><D3BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,coil,2640,,
+,BOOL,<EFBFBD>쳣265-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1#<23><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>ʧ<EFBFBD><CAA7>,coil,2650,,
+,BOOL,<EFBFBD>쳣266-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2#<23><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>ʧ<EFBFBD><CAA7>,coil,2660,,
+,BOOL,<EFBFBD>쳣267-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>3#<23><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>ʧ<EFBFBD><CAA7>,coil,2670,,
+,BOOL,<EFBFBD>쳣268-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4#<23><><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1>ʧ<EFBFBD><CAA7>,coil,2680,,
+,BOOL,<EFBFBD>쳣269-RB<52><42><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>,coil,2690,,
+,BOOL,<EFBFBD>쳣280-RB<52><42>ײ<EFBFBD>쳣,coil,2800,,
+,BOOL,<EFBFBD>쳣290-<2D>Ӿ<EFBFBD>ϵͳͨѶ<CDA8>쳣,coil,2900,,
+,BOOL,<EFBFBD>쳣291-<2D>Ӿ<EFBFBD><D3BE><EFBFBD>λNG<4E>쳣,coil,2910,,
+,BOOL,<EFBFBD>쳣292-ɨ<><C9A8>ǹͨѶ<CDA8>쳣,coil,2920,,
+,BOOL,<EFBFBD>쳣310-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3100,,
+,BOOL,<EFBFBD>쳣311-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3110,,
+,BOOL,<EFBFBD>쳣312-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3120,,
+,BOOL,<EFBFBD>쳣313-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3130,,
+,BOOL,<EFBFBD>쳣340-<2D><>·<EFBFBD><C2B7>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3400,,
+,BOOL,<EFBFBD>쳣342-<2D><>·<EFBFBD><C2B7>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3420,,
+,BOOL,<EFBFBD>쳣344-<2D><>·<EFBFBD><C2B7>ѹ<EFBFBD><D1B9>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3440,,
+,BOOL,<EFBFBD>쳣350-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3500,,
+,BOOL,<EFBFBD>쳣352-<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3520,,
+,BOOL,<EFBFBD>쳣354-<2D><>ϴ<EFBFBD>޳<EFBFBD><DEB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3540,,
+,BOOL,<EFBFBD>쳣356-<2D><>ϴ<EFBFBD>޳<EFBFBD><DEB3><EFBFBD>ѹ<EFBFBD><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3560,,
+,BOOL,<EFBFBD>쳣360-<2D><><EFBFBD><EFBFBD>Һƿ<D2BA><C6BF>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3600,,
+,BOOL,<EFBFBD>쳣362-<2D><>Һǹͷ<C7B9>ж<EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3620,,
+COIL ALARM_364_SERVO_DRIVE_ERROR,BOOL,<EFBFBD>쳣364-<2D>Լ<EFBFBD>ƿ<EFBFBD><C6BF>צ<EFBFBD><D7A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3640,,
+COIL ALARM_367_SERVO_DRIVER_ERROR,BOOL,<EFBFBD>쳣366-<2D>Լ<EFBFBD>ƿ<EFBFBD><C6BF>צ<EFBFBD><D7A6><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3660,,
+COIL ALARM_370_SERVO_MODULE_ERROR,BOOL,<EFBFBD>쳣370-ѹ<><D1B9>ģ<EFBFBD>鴵<EFBFBD><E9B4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣,coil,3700,,
+,,,,,,
+,,,,,,
+,,,,,,
+,,,,,,
+,,,,,,
+,,,,,,
+,,,,,,
+COIL + <20><><EFBFBD><EFBFBD>ģ<EFBFBD><C4A3>/<2F><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д+<2B>»<EFBFBD><C2BB>߷ָ<DFB7><D6B8><EFBFBD>--<2D><><EFBFBD><EFBFBD>boolֵ,,,,,,
+REG +  <20><><EFBFBD><EFBFBD>ģ<EFBFBD><C4A3>/<2F><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д+<2B>»<EFBFBD><C2BB>߷ָ<DFB7><D6B8><EFBFBD>--<2D><><EFBFBD>ԼĴ<D4BC><C4B4><EFBFBD>,,,,,,

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv

@@ -0,0 +1,130 @@
+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
+REG_UNILAB_INTERACT,BOOL,,,,coil,8450,
+,,,,,coil,8320,
+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,,,,coil,8360,
+,BOOL,,,,coil,8300,
+,BOOL,,,,coil,8310,
+COIL_GB_L_IGNORE_CMD,BOOL,,,,coil,8320,
+COIL_GB_R_IGNORE_CMD,BOOL,,,,coil,8420,
+,BOOL,,,,coil,8350,
+COIL_ELECTROLYTE_DUAL_DROP_MODE,BOOL,,,,coil,8370,
+,BOOL,,,,coil,8380,
+,BOOL,,,,coil,8390,
+,BOOL,,,,coil,8400,
+,BOOL,,,,coil,8410,
+REG_MSG_DUAL_DROP_FIRST_VOLUME,INT16,,,,hold_register,4001,
+COIL_DUAL_DROP_SUCTION_TIMING,BOOL,,,,coil,8430,
+COIL_DUAL_DROP_START_TIMING,BOOL,,,,coil,8470,
+REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,,,coil,8460,
+COIL_ALARM_100_SYSTEM_ERROR,BOOL,,,,coil,1000,异常100-系统异常
+COIL_ALARM_101_EMERGENCY_STOP,BOOL,,,,coil,1010,异常101-急停
+COIL_ALARM_111_GLOVEBOX_EMERGENCY_STOP,BOOL,,,,coil,1110,异常111-手套箱急停
+COIL_ALARM_112_GLOVEBOX_GRATING_BLOCKED,BOOL,,,,coil,1120,异常112-手套箱内光栅遮挡
+COIL_ALARM_160_PIPETTE_TIP_SHORTAGE,BOOL,,,,coil,1600,异常160-移液枪头缺料
+COIL_ALARM_161_POSITIVE_SHELL_SHORTAGE,BOOL,,,,coil,1610,异常161-正极壳缺料
+COIL_ALARM_162_ALUMINUM_FOIL_SHORTAGE,BOOL,,,,coil,1620,异常162-铝箔垫缺料
+COIL_ALARM_163_POSITIVE_PLATE_SHORTAGE,BOOL,,,,coil,1630,异常163-正极片缺料
+COIL_ALARM_164_SEPARATOR_SHORTAGE,BOOL,,,,coil,1640,异常164-隔膜缺料
+COIL_ALARM_165_NEGATIVE_PLATE_SHORTAGE,BOOL,,,,coil,1650,异常165-负极片缺料
+COIL_ALARM_166_FLAT_WASHER_SHORTAGE,BOOL,,,,coil,1660,异常166-平垫缺料
+COIL_ALARM_167_SPRING_WASHER_SHORTAGE,BOOL,,,,coil,1670,异常167-弹垫缺料
+COIL_ALARM_168_NEGATIVE_SHELL_SHORTAGE,BOOL,,,,coil,1680,异常168-负极壳缺料
+COIL_ALARM_169_FINISHED_BATTERY_FULL,BOOL,,,,coil,1690,异常169-成品电池满料
+COIL_ALARM_201_SERVO_AXIS_01_ERROR,BOOL,,,,coil,2010,异常201-伺服轴01异常
+COIL_ALARM_202_SERVO_AXIS_02_ERROR,BOOL,,,,coil,2020,异常202-伺服轴02异常
+COIL_ALARM_203_SERVO_AXIS_03_ERROR,BOOL,,,,coil,2030,异常203-伺服轴03异常
+COIL_ALARM_204_SERVO_AXIS_04_ERROR,BOOL,,,,coil,2040,异常204-伺服轴04异常
+COIL_ALARM_205_SERVO_AXIS_05_ERROR,BOOL,,,,coil,2050,异常205-伺服轴05异常
+COIL_ALARM_206_SERVO_AXIS_06_ERROR,BOOL,,,,coil,2060,异常206-伺服轴06异常
+COIL_ALARM_207_SERVO_AXIS_07_ERROR,BOOL,,,,coil,2070,异常207-伺服轴07异常
+COIL_ALARM_208_SERVO_AXIS_08_ERROR,BOOL,,,,coil,2080,异常208-伺服轴08异常
+COIL_ALARM_209_SERVO_AXIS_09_ERROR,BOOL,,,,coil,2090,异常209-伺服轴09异常
+COIL_ALARM_210_SERVO_AXIS_10_ERROR,BOOL,,,,coil,2100,异常210-伺服轴10异常
+COIL_ALARM_211_SERVO_AXIS_11_ERROR,BOOL,,,,coil,2110,异常211-伺服轴11异常
+COIL_ALARM_212_SERVO_AXIS_12_ERROR,BOOL,,,,coil,2120,异常212-伺服轴12异常
+COIL_ALARM_213_SERVO_AXIS_13_ERROR,BOOL,,,,coil,2130,异常213-伺服轴13异常
+COIL_ALARM_214_SERVO_AXIS_14_ERROR,BOOL,,,,coil,2140,异常214-伺服轴14异常
+COIL_ALARM_250_OTHER_COMPONENT_ERROR,BOOL,,,,coil,2500,异常250-其他元件异常
+COIL_ALARM_251_PIPETTE_COMM_ERROR,BOOL,,,,coil,2510,异常251-移液枪通讯异常
+COIL_ALARM_252_PIPETTE_ALARM,BOOL,,,,coil,2520,异常252-移液枪报警
+COIL_ALARM_256_ELECTRIC_GRIPPER_ERROR,BOOL,,,,coil,2560,异常256-电爪异常
+COIL_ALARM_262_RB_UNKNOWN_POSITION_ERROR,BOOL,,,,coil,2620,异常262-RB报警：未知点位错误
+COIL_ALARM_263_RB_XYZ_PARAM_LIMIT_ERROR,BOOL,,,,coil,2630,异常263-RB报警：X、Y、Z参数超限制
+COIL_ALARM_264_RB_VISION_PARAM_ERROR,BOOL,,,,coil,2640,异常264-RB报警：视觉参数误差过大
+COIL_ALARM_265_RB_NOZZLE_1_PICK_FAIL,BOOL,,,,coil,2650,异常265-RB报警：1#吸嘴取料失败
+COIL_ALARM_266_RB_NOZZLE_2_PICK_FAIL,BOOL,,,,coil,2660,异常266-RB报警：2#吸嘴取料失败
+COIL_ALARM_267_RB_NOZZLE_3_PICK_FAIL,BOOL,,,,coil,2670,异常267-RB报警：3#吸嘴取料失败
+COIL_ALARM_268_RB_NOZZLE_4_PICK_FAIL,BOOL,,,,coil,2680,异常268-RB报警：4#吸嘴取料失败
+COIL_ALARM_269_RB_TRAY_PICK_FAIL,BOOL,,,,coil,2690,异常269-RB报警：取物料盘失败
+COIL_ALARM_280_RB_COLLISION_ERROR,BOOL,,,,coil,2800,异常280-RB碰撞异常
+COIL_ALARM_290_VISION_SYSTEM_COMM_ERROR,BOOL,,,,coil,2900,异常290-视觉系统通讯异常
+COIL_ALARM_291_VISION_ALIGNMENT_NG,BOOL,,,,coil,2910,异常291-视觉对位NG异常
+COIL_ALARM_292_BARCODE_SCANNER_COMM_ERROR,BOOL,,,,coil,2920,异常292-扫码枪通讯异常
+COIL_ALARM_310_OCV_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3100,异常310-开电移载吸嘴吸真空异常
+COIL_ALARM_311_OCV_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3110,异常311-开电移载吸嘴破真空异常
+COIL_ALARM_312_WEIGHT_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3120,异常312-称重移载吸嘴吸真空异常
+COIL_ALARM_313_WEIGHT_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3130,异常313-称重移载吸嘴破真空异常
+COIL_ALARM_340_OCV_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3400,异常340-开路电压吸嘴移载气缸异常
+COIL_ALARM_342_OCV_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3420,异常342-开路电压吸嘴升降气缸异常
+COIL_ALARM_344_OCV_CRIMPING_CYLINDER_ERROR,BOOL,,,,coil,3440,异常344-开路电压旋压气缸异常
+COIL_ALARM_350_WEIGHT_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3500,异常350-称重吸嘴移载气缸异常
+COIL_ALARM_352_WEIGHT_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3520,异常352-称重吸嘴升降气缸异常
+COIL_ALARM_354_CLEANING_CLOTH_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3540,异常354-清洗无尘布移载气缸异常
+COIL_ALARM_356_CLEANING_CLOTH_PRESS_CYLINDER_ERROR,BOOL,,,,coil,3560,异常356-清洗无尘布压紧气缸异常
+COIL_ALARM_360_ELECTROLYTE_BOTTLE_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3600,异常360-电解液瓶定位气缸异常
+COIL_ALARM_362_PIPETTE_TIP_BOX_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3620,异常362-移液枪头盒定位气缸异常
+COIL_ALARM_364_REAGENT_BOTTLE_GRIPPER_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3640,异常364-试剂瓶夹爪升降气缸异常
+COIL_ALARM_366_REAGENT_BOTTLE_GRIPPER_CYLINDER_ERROR,BOOL,,,,coil,3660,异常366-试剂瓶夹爪气缸异常
+COIL_ALARM_370_PRESS_MODULE_BLOW_CYLINDER_ERROR,BOOL,,,,coil,3700,异常370-压制模块吹气气缸异常
+COIL_ALARM_151_ELECTROLYTE_BOTTLE_POSITION_ERROR,BOOL,,,,coil,1510,异常151-电解液瓶定位在籍异常
+COIL_ALARM_152_ELECTROLYTE_BOTTLE_CAP_ERROR,BOOL,,,,coil,1520,异常152-电解液瓶盖在籍异常

unilabos/devices/workstation/coin_cell_assembly/date_20251224.csv

@@ -0,0 +1,2 @@
+Time,open_circuit_voltage,pole_weight,assembly_time,assembly_pressure,electrolyte_volume,coin_num,electrolyte_code,coin_cell_code
+20251224_172304,-5.537573695435827e-37,-48.45097351074219,1.372190511464448e+16,3820,30,7,b'\x00\x00d\x00eaoR',b'\x00\x00\x01\x00\x00\x00\r\n'

unilabos/devices/workstation/coin_cell_assembly/date_20251225.csv

@@ -0,0 +1,2 @@
+Time,open_circuit_voltage,pole_weight,assembly_time,assembly_pressure,electrolyte_volume,coin_num,electrolyte_code,coin_cell_code
+20251225_105600,5.566961054206384e-37,-53149746331648.0,3271557120.0,3658,10,7,b'\x00\x00d\x00eaoR',b'\x00\x00\x01\x00\x00\x00\r\n'

unilabos/devices/workstation/coin_cell_assembly/date_20251229.csv

@@ -0,0 +1,2 @@
+Time,open_circuit_voltage,pole_weight,assembly_time,assembly_pressure,electrolyte_volume,coin_num,electrolyte_code,coin_cell_code
+20251229_161836,-5.537573695435827e-37,8.919000478163591e+20,-3.806253867691382e-29,3544,20,7,b'\x00\x00d\x00eaoR',b'\x00\x00\x01\x00\x00\x00\r\n'

unilabos/devices/workstation/coin_cell_assembly/date_20251230.csv

@@ -0,0 +1,9 @@
+Time,open_circuit_voltage,pole_weight,assembly_time,assembly_pressure,electrolyte_volume,coin_num,electrolyte_code,coin_cell_code
+20251230_182319,0.01600000075995922,13.899999618530273,175.0,3836,20,7,b'\x00\x00d\x00eaoR',b'\x00\x00\x01\x00\x00\x00\r\n'
+20251230_185306,0.01600000075995922,13.639999389648438,625.0,3819,20,7,deaoR,

+20251230_192124,0.0,8.949999809265137,414.0,3803,20,8,deaoR,

+20251230_195621,3.8359999656677246,10.069999694824219,205.0,3350,20,8,LG600001,19311909
+20251230_200830,0.7929999828338623,9.34999942779541,18.0,3318,20,8,LG600001,19533419
+20251230_201123,0.0,9.169999122619629,17.0,3269,20,8,LG600001,20054389
+20251230_201410,0.0,9.569999694824219,18.0,3237,20,8,LG600001,YS102704
+20251230_201659,0.0,9.699999809265137,169.0,3318,20,8,LG600001,20112754

unilabos/devices/workstation/coin_cell_assembly/date_20260106.csv

@@ -0,0 +1,3 @@
+Time,open_circuit_voltage,pole_weight,assembly_time,assembly_pressure,electrolyte_volume,coin_num,electrolyte_code,coin_cell_code
+20260106_221708,0.03200000151991844,26.26999855041504,18.0,3803,30,7,NoRead88,22000063
+20260106_221957,0.11299999803304672,26.26999855041504,170.0,3787,30,7,LG600001,22124813

unilabos/devices/workstation/coin_cell_assembly/interactive_battery_export_demo.py

@@ -0,0 +1,536 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""扣式电池组装系统 - 交互式CSV导出演示脚本（增强版）
+
+此脚本专为交互式使用优化，提供清洁的命令行界面，
+禁用了所有调试信息输出，确保用户可以顺畅地输入命令。
+
+主要功能:
+1. 手动导出设备数据到CSV文件（包含6个关键数据字段）
+2. 查看CSV文件内容和导出状态
+3. 兼容原有的电池组装完成状态自动导出功能
+4. 实时查看设备数据和电池数量
+
+数据字段:
+- timestamp: 时间戳
+- assembly_time: 单颗电池组装时间（秒）
+- open_circuit_voltage: 开路电压值（V）
+- pole_weight: 正极片称重数据（g）
+- battery_qr_code: 电池二维码序列号
+- electrolyte_qr_code: 电解液二维码序列号
+
+使用方法:
+1. 确保设备已连接并可正常通信
+2. 运行此脚本: python interactive_battery_export_demo.py
+3. 使用交互式命令控制导出功能
+"""
+
+import time
+import os
+import sys
+import logging
+import csv
+from datetime import datetime
+from pathlib import Path
+
+# 完全禁用所有调试和信息级别的日志输出
+logging.getLogger().setLevel(logging.CRITICAL)
+logging.getLogger('pymodbus').setLevel(logging.CRITICAL)
+logging.getLogger('unilabos').setLevel(logging.CRITICAL)
+logging.getLogger('pymodbus.logging').setLevel(logging.CRITICAL)
+logging.getLogger('pymodbus.logging.tcp').setLevel(logging.CRITICAL)
+logging.getLogger('pymodbus.logging.base').setLevel(logging.CRITICAL)
+logging.getLogger('pymodbus.logging.decoders').setLevel(logging.CRITICAL)
+
+# 添加当前目录到Python路径，以便正确导入模块
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir.parent.parent.parent))  # 添加unilabos根目录
+sys.path.insert(0, str(current_dir))  # 添加当前目录
+
+# 导入扣式电池组装系统
+try:
+    from unilabos.devices.coin_cell_assembly.coin_cell_assembly_system import Coin_Cell_Assembly
+except ImportError:
+    # 如果上述导入失败，尝试直接导入
+    try:
+        from coin_cell_assembly_system import Coin_Cell_Assembly
+    except ImportError as e:
+        print(f"导入错误: {e}")
+        print("请确保在正确的目录下运行此脚本，或者将unilabos添加到Python路径中")
+        sys.exit(1)
+
+def clear_screen():
+    """清屏函数"""
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+def print_header():
+    """打印程序头部信息"""
+    print("="*60)
+    print("    扣式电池组装系统 - 交互式CSV导出控制台")
+    print("="*60)
+    print()
+
+def print_commands():
+    """打印可用命令"""
+    print("可用命令:")
+    print("  start   - 启动电池组装完成状态导出")
+    print("  stop    - 停止导出")
+    print("  status  - 查看导出状态")
+    print("  data    - 查看当前设备数据")
+    print("  count   - 查看当前电池数量")
+    print("  export  - 手动导出当前数据到CSV")
+    print("  setpath - 设置自定义CSV文件路径")
+    print("  view    - 查看CSV文件内容")
+    print("  force   - 强制继续CSV导出(即使设备停止)")
+    print("  detail  - 显示详细设备状态")
+    print("  clear   - 清屏")
+    print("  help    - 显示帮助信息")
+    print("  quit    - 退出程序")
+    print("-"*60)
+
+def print_status_info(device, csv_file_path):
+    """打印状态信息"""
+    try:
+        status = device.get_csv_export_status()
+        is_running = status.get('running', False)
+        export_file = status.get('file_path', None)
+        thread_alive = status.get('thread_alive', False)
+        device_status = status.get('device_status', 'N/A')
+        battery_count = status.get('battery_count', 'N/A')
+        
+        print(f"导出状态: {'运行中' if is_running else '已停止'}")
+        print(f"导出文件: {export_file if export_file else 'N/A'}")
+        print(f"线程状态: {'活跃' if thread_alive else '非活跃'}")
+        print(f"设备状态: {device_status}")
+        print(f"电池计数: {battery_count}")
+        
+        # 检查手动导出的CSV文件
+        if os.path.exists(csv_file_path):
+            file_size = os.path.getsize(csv_file_path)
+            print(f"手动导出文件: {csv_file_path} ({file_size} 字节)")
+        else:
+            print(f"手动导出文件: {csv_file_path} (不存在)")
+            
+        # 显示设备运行状态
+        try:
+            print("\n=== 设备运行状态 ===")
+            print(f"系统启动状态: {device.sys_start_status}")
+            print(f"系统停止状态: {device.sys_stop_status}")
+            print(f"自动模式状态: {device.sys_auto_status}")
+            print(f"手动模式状态: {device.sys_hand_status}")
+        except Exception as e:
+            print(f"获取设备运行状态失败: {e}")
+            
+    except Exception as e:
+        print(f"获取状态失败: {e}")
+
+def collect_device_data(device):
+    """收集设备的六个关键数据"""
+    try:
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        
+        # 读取各项数据，添加错误处理和重试机制
+        try:
+            assembly_time = device.data_assembly_time  # 单颗电池组装时间(秒)
+            # 确保返回的是数值类型
+            if isinstance(assembly_time, (list, tuple)) and len(assembly_time) > 0:
+                assembly_time = float(assembly_time[0])
+            else:
+                assembly_time = float(assembly_time)
+        except Exception as e:
+            print(f"读取组装时间失败: {e}")
+            assembly_time = 0.0
+            
+        try:
+            open_circuit_voltage = device.data_open_circuit_voltage  # 开路电压值(V)
+            # 确保返回的是数值类型
+            if isinstance(open_circuit_voltage, (list, tuple)) and len(open_circuit_voltage) > 0:
+                open_circuit_voltage = float(open_circuit_voltage[0])
+            else:
+                open_circuit_voltage = float(open_circuit_voltage)
+        except Exception as e:
+            print(f"读取开路电压失败: {e}")
+            open_circuit_voltage = 0.0
+            
+        try:
+            pole_weight = device.data_pole_weight  # 正极片称重数据(g)
+            # 确保返回的是数值类型
+            if isinstance(pole_weight, (list, tuple)) and len(pole_weight) > 0:
+                pole_weight = float(pole_weight[0])
+            else:
+                pole_weight = float(pole_weight)
+        except Exception as e:
+            print(f"读取正极片重量失败: {e}")
+            pole_weight = 0.0
+            
+        try:
+            assembly_pressure = device.data_assembly_pressure  # 电池压制力(N)
+            # 确保返回的是数值类型
+            if isinstance(assembly_pressure, (list, tuple)) and len(assembly_pressure) > 0:
+                assembly_pressure = int(assembly_pressure[0])
+            else:
+                assembly_pressure = int(assembly_pressure)
+        except Exception as e:
+            print(f"读取压制力失败: {e}")
+            assembly_pressure = 0
+            
+        try:
+            battery_qr_code = device.data_coin_cell_code  # 电池二维码序列号
+            # 处理字符串类型数据
+            if isinstance(battery_qr_code, str):
+                battery_qr_code = battery_qr_code.strip()
+            else:
+                battery_qr_code = str(battery_qr_code)
+        except Exception as e:
+            print(f"读取电池二维码失败: {e}")
+            battery_qr_code = "N/A"
+            
+        try:
+            electrolyte_qr_code = device.data_electrolyte_code  # 电解液二维码序列号
+            # 处理字符串类型数据
+            if isinstance(electrolyte_qr_code, str):
+                electrolyte_qr_code = electrolyte_qr_code.strip()
+            else:
+                electrolyte_qr_code = str(electrolyte_qr_code)
+        except Exception as e:
+            print(f"读取电解液二维码失败: {e}")
+            electrolyte_qr_code = "N/A"
+        
+        # 获取电池数量
+        try:
+            battery_count = device.data_assembly_coin_cell_num
+            # 确保返回的是数值类型
+            if isinstance(battery_count, (list, tuple)) and len(battery_count) > 0:
+                battery_count = int(battery_count[0])
+            else:
+                battery_count = int(battery_count)
+        except Exception as e:
+            print(f"读取电池数量失败: {e}")
+            battery_count = 0
+        
+        return {
+            'Timestamp': timestamp,
+            'Battery_Count': battery_count,
+            'Assembly_Time': assembly_time,
+            'Open_Circuit_Voltage': open_circuit_voltage,
+            'Pole_Weight': pole_weight,
+            'Assembly_Pressure': assembly_pressure,
+            'Battery_Code': battery_qr_code,
+            'Electrolyte_Code': electrolyte_qr_code
+        }
+    except Exception as e:
+        print(f"收集数据时出错: {e}")
+        return None
+
+def export_to_csv(data, csv_file_path):
+    """将数据导出到CSV文件"""
+    try:
+        # 检查文件是否存在，如果不存在则创建并写入表头
+        file_exists = os.path.exists(csv_file_path)
+        
+        # 确保目录存在
+        csv_dir = os.path.dirname(csv_file_path)
+        if csv_dir:
+            os.makedirs(csv_dir, exist_ok=True)
+        
+        # 确保数值字段为正确的数值类型，避免前导单引号问题
+        processed_data = data.copy()
+        
+        # 处理数值字段，确保它们是数值类型而不是字符串，增强错误处理
+        numeric_fields = ['Battery_Count', 'Assembly_Time', 'Open_Circuit_Voltage', 'Pole_Weight', 'Assembly_Pressure']
+        for field in numeric_fields:
+            if field in processed_data:
+                try:
+                    value = processed_data[field]
+                    # 处理可能的列表或元组类型
+                    if isinstance(value, (list, tuple)) and len(value) > 0:
+                        value = value[0]
+                    
+                    if field == 'Battery_Count' or field == 'Assembly_Pressure':
+                        processed_data[field] = int(float(value))  # 先转float再转int，处理字符串数字
+                    else:
+                        processed_data[field] = float(value)
+                except (ValueError, TypeError, IndexError) as e:
+                    print(f"字段 {field} 类型转换失败: {e}, 使用默认值")
+                    processed_data[field] = 0 if field == 'Battery_Count' else 0.0
+        
+        # 处理字符串字段
+        for field in ['Battery_Code', 'Electrolyte_Code']:
+            if field in processed_data:
+                try:
+                    value = processed_data[field]
+                    if isinstance(value, (list, tuple)) and len(value) > 0:
+                        value = value[0]
+                    processed_data[field] = str(value).strip()
+                except Exception as e:
+                    print(f"字段 {field} 处理失败: {e}, 使用默认值")
+                    processed_data[field] = "N/A"
+        
+        with open(csv_file_path, 'a', newline='', encoding='utf-8') as csvfile:
+            fieldnames = ['Timestamp', 'Battery_Count', 'Assembly_Time', 'Open_Circuit_Voltage', 
+                         'Pole_Weight', 'Assembly_Pressure', 'Battery_QR_Code', 'Electrolyte_QR_Code']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames, quoting=csv.QUOTE_MINIMAL)
+            
+            # 如果文件不存在，写入表头
+            if not file_exists:
+                writer.writeheader()
+                print(f"创建新的CSV文件: {csv_file_path}")
+            
+            # 写入数据
+            writer.writerow(processed_data)
+            print(f"数据已导出到: {csv_file_path}")
+        
+        return True
+    except Exception as e:
+        print(f"导出CSV时出错: {e}")
+        return False
+
+def view_csv_content(csv_file_path, lines=10):
+    """查看CSV文件内容"""
+    try:
+        if not os.path.exists(csv_file_path):
+            print("CSV文件不存在")
+            return
+        
+        with open(csv_file_path, 'r', encoding='utf-8') as csvfile:
+            content = csvfile.readlines()
+            
+        if not content:
+            print("CSV文件为空")
+            return
+        
+        print(f"CSV文件内容 (显示最后{min(lines, len(content))}行):")
+        print("-" * 80)
+        
+        # 显示表头
+        if len(content) > 0:
+            print(content[0].strip())
+            print("-" * 80)
+        
+        # 显示最后几行数据
+        start_line = max(1, len(content) - lines + 1)
+        for i in range(start_line, len(content)):
+            print(content[i].strip())
+        
+        print("-" * 80)
+        print(f"总共 {len(content)-1} 条数据记录")
+        
+    except Exception as e:
+        print(f"读取CSV文件时出错: {e}")
+
+def interactive_demo():
+    """
+    交互式演示模式（优化版）
+    """
+    clear_screen()
+    print_header()
+    
+    print("正在初始化设备连接...")
+    print("设备地址: 192.168.1.20:502")
+    print("正在尝试连接...")
+    
+    try:
+        device = Coin_Cell_Assembly(address="192.168.1.20", port="502")
+        print("✓ 设备连接成功")
+        
+        # 测试设备数据读取
+        print("正在测试设备数据读取...")
+        try:
+            test_count = device.data_assembly_coin_cell_num
+            print(f"✓ 当前电池数量: {test_count}")
+        except Exception as e:
+            print(f"⚠ 数据读取测试失败: {e}")
+            print("设备连接正常，但数据读取可能存在问题")
+            
+    except Exception as e:
+        print(f"✗ 设备连接失败: {e}")
+        print("请检查以下项目:")
+        print("1. 设备是否已开机并正常运行")
+        print("2. 网络连接是否正常")
+        print("3. 设备IP地址是否为192.168.1.20")
+        print("4. Modbus服务是否在端口502上运行")
+        input("按回车键退出...")
+        return
+    
+    csv_file_path = "battery_data_export.csv"
+    print(f"CSV文件路径: {os.path.abspath(csv_file_path)}")
+    print()
+    print("功能说明:")
+    print("- 支持手动导出当前设备数据到CSV文件")
+    print("- 包含六个关键数据: 组装时间、开路电压、正极片重量、电池码、电解液码")
+    print("- 电池码和电解液码可能显示为N/A（当二维码读取失败时）")
+    print("- 支持查看CSV文件内容和导出状态")
+    print("- 兼容原有的电池组装完成状态自动导出功能")
+    print()
+    
+    print_commands()
+    
+    while True:
+        try:
+            command = input("\n请输入命令 > ").strip().lower()
+            
+            if command == "start":
+                print("启动电池组装完成状态导出...")
+                try:
+                    success, message = device.start_battery_completion_export(csv_file_path)
+                    if success:
+                        print(f"✓ {message}")
+                        print("系统正在监控电池组装完成状态...")
+                    else:
+                        print(f"✗ {message}")
+                except Exception as e:
+                    print(f"启动导出时出错: {e}")
+            
+            elif command == "stop":
+                 print("停止导出...")
+                 try:
+                     success, message = device.stop_csv_export()
+                     if success:
+                         print(f"✓ {message}")
+                     else:
+                         print(f"✗ {message}")
+                 except Exception as e:
+                     print(f"停止导出时出错: {e}")
+            
+            elif command == "force":
+                print("强制继续CSV导出...")
+                try:
+                    success, message = device.force_continue_csv_export()
+                    if success:
+                        print(f"✓ {message}")
+                        print("注意: CSV导出将继续监控数据变化，即使设备处于停止状态")
+                    else:
+                        print(f"✗ {message}")
+                except AttributeError:
+                    print("✗ 当前版本不支持强制继续功能")
+                except Exception as e:
+                    print(f"✗ 强制继续失败: {e}")
+                    
+            elif command == "detail":
+                print("=== 详细设备状态 ===")
+                print_status_info(device, csv_file_path)
+            
+            elif command == "status":
+                print_status_info(device, csv_file_path)
+            
+            elif command == "data":
+                print("读取当前设备数据...")
+                try:
+                    data = collect_device_data(device)
+                    if data:
+                        print("\n=== 当前设备数据 ===")
+                        print(f"时间戳: {data['Timestamp']}")
+                        print(f"电池数量: {data['Battery_Count']}")
+                        print(f"单颗电池组装时间: {data['Assembly_Time']:.2f} 秒")
+                        print(f"开路电压值: {data['Open_Circuit_Voltage']:.4f} V")
+                        print(f"正极片称重数据: {data['Pole_Weight']:.4f} g")
+                        print(f"电池压制力: {data['Assembly_Pressure']} N")
+                        print(f"电池二维码序列号: {data['Battery_Code']}")
+                        print(f"电解液二维码序列号: {data['Electrolyte_Code']}")
+                        print("===================")
+                    else:
+                        print("无法获取设备数据")
+                except Exception as e:
+                    print(f"读取数据时出错: {e}")
+            
+            elif command == "count":
+                print("读取当前电池数量...")
+                try:
+                    count = device.data_assembly_coin_cell_num
+                    print(f"当前已完成电池数量: {count}")
+                except Exception as e:
+                    print(f"读取电池数量时出错: {e}")
+            
+            elif command == "export":
+                print("正在收集设备数据并导出到CSV...")
+                data = collect_device_data(device)
+                if data:
+                    print(f"收集到数据: 电池数量={data.get('Battery_Count', 'N/A')}, 组装时间={data.get('Assembly_Time', 'N/A')}s")
+                    if export_to_csv(data, csv_file_path):
+                        print("✓ 数据已成功导出到CSV文件")
+                        print(f"导出数据: 时间={data['Timestamp']}, 电池数量={data['Battery_Count']}, 组装时间={data['Assembly_Time']}秒, "
+                              f"电压={data['Open_Circuit_Voltage']}V, 重量={data['Pole_Weight']}g, 压制力={data['Assembly_Pressure']}N")
+                        print(f"电池码={data['Battery_Code']}, 电解液码={data['Electrolyte_Code']}")
+                    else:
+                        print("✗ 导出失败")
+                else:
+                    print("✗ 数据收集失败，无法导出！请检查设备连接状态。")
+                    # 尝试重新连接设备
+                    try:
+                        if hasattr(device, 'connect'):
+                            device.connect()
+                            print("尝试重新连接设备...")
+                    except Exception as e:
+                        print(f"重新连接失败: {e}")
+            
+            elif command == "setpath":
+                print("设置自定义CSV文件路径")
+                print(f"当前CSV文件路径: {csv_file_path}")
+                new_path = input("请输入新的CSV文件路径（包含文件名，如: D:/data/my_battery_data.csv）: ").strip()
+                if new_path:
+                    try:
+                        # 确保目录存在
+                        new_dir = os.path.dirname(new_path)
+                        if new_dir and not os.path.exists(new_dir):
+                            os.makedirs(new_dir, exist_ok=True)
+                            print(f"✓ 已创建目录: {new_dir}")
+                        
+                        csv_file_path = new_path
+                        print(f"✓ CSV文件路径已更新为: {os.path.abspath(csv_file_path)}")
+                        
+                        # 检查文件是否存在
+                        if os.path.exists(csv_file_path):
+                            file_size = os.path.getsize(csv_file_path)
+                            print(f"文件已存在，大小: {file_size} 字节")
+                        else:
+                            print("文件不存在，将在首次导出时创建")
+                    except Exception as e:
+                        print(f"✗ 设置路径失败: {e}")
+                else:
+                    print("路径不能为空")
+            
+            elif command == "view":
+                print("查看CSV文件内容...")
+                view_csv_content(csv_file_path)
+            
+            elif command == "clear":
+                clear_screen()
+                print_header()
+                print_commands()
+            
+            elif command == "help":
+                print_commands()
+            
+            elif command == "quit" or command == "exit":
+                print("正在退出...")
+                # 停止导出
+                try:
+                    device.stop_csv_export()
+                    print("✓ 导出已停止")
+                except:
+                    pass
+                print("程序已退出")
+                break
+            
+            elif command == "":
+                # 空命令，不做任何操作
+                continue
+            
+            else:
+                print(f"未知命令: {command}")
+                print("输入 'help' 查看可用命令")
+        
+        except KeyboardInterrupt:
+            print("\n\n检测到 Ctrl+C，正在退出...")
+            try:
+                device.stop_csv_export()
+                print("✓ 导出已停止")
+            except:
+                pass
+            print("程序已退出")
+            break
+        except Exception as e:
+            print(f"执行命令时出错: {e}")
+
+if __name__ == '__main__':
+    interactive_demo()

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/coin_cell_assembly/电池资源冲突修复说明.md

@@ -0,0 +1,107 @@
+# 电池组装资源冲突问题修复说明
+
+## 问题描述
+
+在运行 `func_allpack_cmd` 函数时，遇到以下错误：
+
+```
+ValueError: Resource 'battery_0' already assigned to deck
+```
+
+**错误位置**：`coin_cell_assembly.py` 第 849 行
+```python
+liaopan3.children[self.coin_num_N].assign_child_resource(battery, location=None)
+```
+
+## 原因分析
+
+1. **资源名称冲突**：
+   - 每次创建电池资源使用固定格式 `battery_{coin_num_N}`
+   - 如果程序重启或断点恢复，`coin_num_N` 可能重置为 0
+   - Deck 上可能已存在 `battery_0` 等同名资源
+
+2. **缺少冲突处理**：
+   - 在分配资源前没有检查目标位置是否已有资源
+   - 没有清理机制来移除旧资源
+
+## 解决方案
+
+### 1. 使用时间戳确保资源名称唯一
+
+```python
+# 之前
+battery = ElectrodeSheet(name=f"battery_{self.coin_num_N}", ...)
+
+# 修复后
+timestamp_suffix = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+battery_name = f"battery_{self.coin_num_N}_{timestamp_suffix}"
+battery = ElectrodeSheet(name=battery_name, ...)
+```
+
+### 2. 添加资源冲突检查和清理
+
+```python
+# 检查目标位置是否已有资源
+target_slot = liaopan3.children[self.coin_num_N]
+if target_slot.children:
+    logger.warning(f"位置 {self.coin_num_N} 已有资源，将先卸载旧资源")
+    try:
+        # 卸载所有现有子资源
+        for child in list(target_slot.children):
+            target_slot.unassign_child_resource(child)
+            logger.info(f"已卸载旧资源: {child.name}")
+    except Exception as e:
+        logger.error(f"卸载旧资源时出错: {e}")
+```
+
+### 3. 增强错误处理
+
+```python
+# 分配新资源到目标位置
+try:
+    target_slot.assign_child_resource(battery, location=None)
+    logger.info(f"成功分配电池 {battery_name} 到位置 {self.coin_num_N}")
+except Exception as e:
+    logger.error(f"分配电池资源失败: {e}")
+    raise
+```
+
+## 修复效果
+
+✅ **不再出现重复资源名称错误**
+- 每个电池资源都有唯一的时间戳后缀
+- 即使 `coin_num_N` 相同，资源名称也不会冲突
+
+✅ **自动清理旧资源**
+- 在分配新资源前检查目标位置
+- 自动卸载已存在的旧资源
+
+✅ **增强日志记录**
+- 记录资源卸载操作
+- 记录资源分配成功/失败
+- 便于调试和问题追踪
+
+## 测试建议
+
+1. **正常运行测试**：
+   ```python
+   workstation.func_allpack_cmd(
+       elec_num=1, 
+       elec_use_num=1, 
+       elec_vol=20, 
+       file_path="..."
+   )
+   ```
+
+2. **断点恢复测试**：
+   - 运行一次后中断
+   - 再次运行相同参数
+   - 验证不会出现资源冲突错误
+
+3. **连续运行测试**：
+   - 连续多次运行
+   - 验证每次都能正常分配资源
+
+## 相关文件
+
+- `coin_cell_assembly.py` - 第 838-875 行（`func_pack_get_msg_cmd` 函数）

unilabos/devices/workstation/workstation_http_service.py

@@ -4,7 +4,7 @@ Workstation HTTP Service Module
 
 统一的工作站报送接收服务，基于LIMS协议规范：
 1. 步骤完成报送 - POST /report/step_finish
-2. 通量完成报送 - POST /report/sample_finish
+2. 通量完成报送 - POST /report/sample_finish  
 3. 任务完成报送 - POST /report/order_finish
 4. 批量更新报送 - POST /report/batch_update
 5. 物料变更报送 - POST /report/material_change
@@ -22,7 +22,6 @@ from http.server import BaseHTTPRequestHandler, HTTPServer
 from urllib.parse import urlparse
 from dataclasses import dataclass, asdict
 from datetime import datetime
-from pathlib import Path
 
 from unilabos.utils.log import logger
 
@@ -55,18 +54,18 @@ class HttpResponse:
 
 class WorkstationHTTPHandler(BaseHTTPRequestHandler):
     """工作站HTTP请求处理器"""
-
+    
     def __init__(self, workstation_instance, *args, **kwargs):
         self.workstation = workstation_instance
         super().__init__(*args, **kwargs)
-
+    
     def do_POST(self):
         """处理POST请求 - 统一的工作站报送接口"""
         try:
             # 解析请求路径
             parsed_path = urlparse(self.path)
             endpoint = parsed_path.path
-
+            
             # 读取请求体
             content_length = int(self.headers.get('Content-Length', 0))
             if content_length > 0:
@@ -74,17 +73,9 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 request_data = json.loads(post_data.decode('utf-8'))
             else:
                 request_data = {}
-
+            
             logger.info(f"收到工作站报送: {endpoint} - {request_data.get('token', 'unknown')}")
-
-            try:
-                payload_for_log = {"method": "POST", **request_data}
-                self._save_raw_request(endpoint, payload_for_log)
-                if hasattr(self.workstation, '_reports_received_count'):
-                    self.workstation._reports_received_count += 1
-            except Exception:
-                pass
-
+            
             # 统一的报送端点路由（基于LIMS协议规范）
             if endpoint == '/report/step_finish':
                 response = self._handle_step_finish_report(request_data)
@@ -99,8 +90,6 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 response = self._handle_material_change_report(request_data)
             elif endpoint == '/report/error_handling':
                 response = self._handle_error_handling_report(request_data)
-            elif endpoint == '/report/temperature-cutoff':
-                response = self._handle_temperature_cutoff_report(request_data)
             # 保留LIMS协议端点以兼容现有系统
             elif endpoint == '/LIMS/step_finish':
                 response = self._handle_step_finish_report(request_data)
@@ -113,19 +102,18 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"不支持的报送端点: {endpoint}",
                     data={"supported_endpoints": [
-                        "/report/step_finish",
-                        "/report/sample_finish",
+                        "/report/step_finish", 
+                        "/report/sample_finish", 
                         "/report/order_finish",
                         "/report/batch_update",
                         "/report/material_change",
-                        "/report/error_handling",
-                        "/report/temperature-cutoff"
+                        "/report/error_handling"
                     ]}
                 )
-
+            
             # 发送响应
             self._send_response(response)
-
+            
         except Exception as e:
             logger.error(f"处理工作站报送失败: {e}\\n{traceback.format_exc()}")
             error_response = HttpResponse(
@@ -133,18 +121,13 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 message=f"请求处理失败: {str(e)}"
             )
             self._send_response(error_response)
-
+    
     def do_GET(self):
         """处理GET请求 - 健康检查和状态查询"""
         try:
             parsed_path = urlparse(self.path)
             endpoint = parsed_path.path
-
-            try:
-                self._save_raw_request(endpoint, {"method": "GET"})
-            except Exception:
-                pass
-
+            
             if endpoint == '/status':
                 response = self._handle_status_check()
             elif endpoint == '/health':
@@ -155,9 +138,9 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     message=f"不支持的查询端点: {endpoint}",
                     data={"supported_endpoints": ["/status", "/health"]}
                 )
-
+            
             self._send_response(response)
-
+            
         except Exception as e:
             logger.error(f"GET请求处理失败: {e}")
             error_response = HttpResponse(
@@ -165,7 +148,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 message=f"GET请求处理失败: {str(e)}"
             )
             self._send_response(error_response)
-
+    
     def do_OPTIONS(self):
         """处理OPTIONS请求 - CORS预检请求"""
         try:
@@ -176,12 +159,12 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
             self.send_header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
             self.send_header('Access-Control-Max-Age', '86400')
             self.end_headers()
-
+            
         except Exception as e:
             logger.error(f"OPTIONS请求处理失败: {e}")
             self.send_response(500)
             self.end_headers()
-
+    
     def _handle_step_finish_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理步骤完成报送（统一LIMS协议规范）"""
         try:
@@ -192,7 +175,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"缺少必要字段: {', '.join(missing_fields)}"
                 )
-
+            
             # 验证data字段内容
             data = request_data['data']
             data_required_fields = ['orderCode', 'orderName', 'stepName', 'stepId', 'sampleId', 'startTime', 'endTime']
@@ -201,31 +184,31 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"data字段缺少必要内容: {', '.join(data_missing_fields)}"
                 )
-
+            
             # 创建统一请求对象
             report_request = WorkstationReportRequest(
                 token=request_data['token'],
                 request_time=request_data['request_time'],
                 data=data
             )
-
+            
             # 调用工作站处理方法
             result = self.workstation.process_step_finish_report(report_request)
-
+            
             return HttpResponse(
                 success=True,
                 message=f"步骤完成报送已处理: {data['stepName']} ({data['orderCode']})",
                 acknowledgment_id=f"STEP_{int(time.time() * 1000)}_{data['stepId']}",
                 data=result
             )
-
+                
         except Exception as e:
             logger.error(f"处理步骤完成报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"步骤完成报送处理失败: {str(e)}"
             )
-
+    
     def _handle_sample_finish_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理通量完成报送（统一LIMS协议规范）"""
         try:
@@ -236,7 +219,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"缺少必要字段: {', '.join(missing_fields)}"
                 )
-
+            
             # 验证data字段内容
             data = request_data['data']
             data_required_fields = ['orderCode', 'orderName', 'sampleId', 'startTime', 'endTime', 'status']
@@ -245,37 +228,37 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"data字段缺少必要内容: {', '.join(data_missing_fields)}"
                 )
-
+            
             # 创建统一请求对象
             report_request = WorkstationReportRequest(
                 token=request_data['token'],
                 request_time=request_data['request_time'],
                 data=data
             )
-
+            
             # 调用工作站处理方法
             result = self.workstation.process_sample_finish_report(report_request)
-
+            
             status_names = {
-                "0": "待生产", "2": "进样", "10": "开始",
+                "0": "待生产", "2": "进样", "10": "开始", 
                 "20": "完成", "-2": "异常停止", "-3": "人工停止"
             }
             status_desc = status_names.get(str(data['status']), f"状态{data['status']}")
-
+            
             return HttpResponse(
                 success=True,
                 message=f"通量完成报送已处理: {data['sampleId']} ({data['orderCode']}) - {status_desc}",
                 acknowledgment_id=f"SAMPLE_{int(time.time() * 1000)}_{data['sampleId']}",
                 data=result
             )
-
+                
         except Exception as e:
             logger.error(f"处理通量完成报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"通量完成报送处理失败: {str(e)}"
             )
-
+    
     def _handle_order_finish_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理任务完成报送（统一LIMS协议规范）"""
         try:
@@ -286,7 +269,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"缺少必要字段: {', '.join(missing_fields)}"
                 )
-
+            
             # 验证data字段内容
             data = request_data['data']
             data_required_fields = ['orderCode', 'orderName', 'startTime', 'endTime', 'status']
@@ -295,7 +278,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"data字段缺少必要内容: {', '.join(data_missing_fields)}"
                 )
-
+            
             # 处理物料使用记录
             used_materials = []
             if 'usedMaterials' in data:
@@ -307,85 +290,41 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                         usedQuantity=material_data.get('usedQuantity', 0.0)
                     )
                     used_materials.append(material)
-
+            
             # 创建统一请求对象
             report_request = WorkstationReportRequest(
                 token=request_data['token'],
                 request_time=request_data['request_time'],
                 data=data
             )
-
+            
             # 调用工作站处理方法
             result = self.workstation.process_order_finish_report(report_request, used_materials)
-
+            
             status_names = {"30": "完成", "-11": "异常停止", "-12": "人工停止"}
             status_desc = status_names.get(str(data['status']), f"状态{data['status']}")
-
+            
             return HttpResponse(
                 success=True,
                 message=f"任务完成报送已处理: {data['orderName']} ({data['orderCode']}) - {status_desc}",
                 acknowledgment_id=f"ORDER_{int(time.time() * 1000)}_{data['orderCode']}",
                 data=result
             )
-
+                
         except Exception as e:
             logger.error(f"处理任务完成报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"任务完成报送处理失败: {str(e)}"
             )
-
-    def _handle_temperature_cutoff_report(self, request_data: Dict[str, Any]) -> HttpResponse:
-        try:
-            required_fields = ['token', 'request_time', 'data']
-            if missing := [f for f in required_fields if f not in request_data]:
-                return HttpResponse(success=False, message=f"缺少必要字段: {', '.join(missing)}")
-
-            data = request_data['data']
-            metrics = [
-                'frameCode',
-                'generateTime',
-                'targetTemperature',
-                'settingTemperature',
-                'inTemperature',
-                'outTemperature',
-                'pt100Temperature',
-                'sensorAverageTemperature',
-                'speed',
-                'force',
-                'viscosity',
-                'averageViscosity'
-            ]
-            if miss := [f for f in metrics if f not in data]:
-                return HttpResponse(success=False, message=f"data字段缺少必要内容: {', '.join(miss)}")
-
-            report_request = WorkstationReportRequest(
-                token=request_data['token'],
-                request_time=request_data['request_time'],
-                data=data
-            )
-
-            result = {}
-            if hasattr(self.workstation, 'process_temperature_cutoff_report'):
-                result = self.workstation.process_temperature_cutoff_report(report_request)
-
-            return HttpResponse(
-                success=True,
-                message=f"温度/粘度报送已处理: 帧{data['frameCode']}",
-                acknowledgment_id=f"TEMP_CUTOFF_{int(time.time()*1000)}_{data['frameCode']}",
-                data=result
-            )
-        except Exception as e:
-            logger.error(f"处理温度/粘度报送失败: {e}\n{traceback.format_exc()}")
-            return HttpResponse(success=False, message=f"温度/粘度报送处理失败: {str(e)}")
-
+    
     def _handle_batch_update_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理批量报送"""
         try:
             step_updates = request_data.get('step_updates', [])
             sample_updates = request_data.get('sample_updates', [])
             order_updates = request_data.get('order_updates', [])
-
+            
             results = {
                 'step_results': [],
                 'sample_results': [],
@@ -393,7 +332,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 'total_processed': 0,
                 'total_failed': 0
             }
-
+            
             # 处理批量步骤更新
             for step_data in step_updates:
                 try:
@@ -408,7 +347,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 except Exception as e:
                     results['step_results'].append(HttpResponse(success=False, message=str(e)))
                     results['total_failed'] += 1
-
+            
             # 处理批量通量更新
             for sample_data in sample_updates:
                 try:
@@ -423,7 +362,7 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 except Exception as e:
                     results['sample_results'].append(HttpResponse(success=False, message=str(e)))
                     results['total_failed'] += 1
-
+            
             # 处理批量任务更新
             for order_data in order_updates:
                 try:
@@ -438,21 +377,21 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 except Exception as e:
                     results['order_results'].append(HttpResponse(success=False, message=str(e)))
                     results['total_failed'] += 1
-
+            
             return HttpResponse(
                 success=results['total_failed'] == 0,
                 message=f"批量报送处理完成: {results['total_processed']} 成功, {results['total_failed']} 失败",
                 acknowledgment_id=f"BATCH_{int(time.time() * 1000)}",
                 data=results
             )
-
+            
         except Exception as e:
             logger.error(f"处理批量报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"批量报送处理失败: {str(e)}"
             )
-
+    
     def _handle_material_change_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理物料变更报送"""
         try:
@@ -478,24 +417,24 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                     success=False,
                     message=f"缺少必要字段: {', '.join(missing_fields)}"
                 )
-
+            
             # 调用工作站的处理方法
             result = self.workstation.process_material_change_report(request_data)
-
+            
             return HttpResponse(
                 success=True,
                 message=f"物料变更报送已处理: {request_data['resource_id']} ({request_data['change_type']})",
                 acknowledgment_id=f"MATERIAL_{int(time.time() * 1000)}_{request_data['resource_id']}",
                 data=result
             )
-
+                
         except Exception as e:
             logger.error(f"处理物料变更报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"物料变更报送处理失败: {str(e)}"
             )
-
+    
     def _handle_error_handling_report(self, request_data: Dict[str, Any]) -> HttpResponse:
         """处理错误处理报送"""
         try:
@@ -507,13 +446,13 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                         success=False,
                         message="奔曜格式缺少text字段"
                     )
-
+                
                 error_data = request_data["text"]
                 logger.info(f"收到奔曜错误处理报送: {error_data}")
-
+                
                 # 调用工作站的处理方法
                 result = self.workstation.handle_external_error(error_data)
-
+                
                 return HttpResponse(
                     success=True,
                     message=f"错误处理报送已收到: 任务{error_data.get('task', 'unknown')}, 错误代码{error_data.get('code', 'unknown')}",
@@ -528,50 +467,42 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                         success=False,
                         message=f"缺少必要字段: {', '.join(missing_fields)}"
                     )
-
+                
                 # 调用工作站的处理方法
                 result = self.workstation.handle_external_error(request_data)
-
+                
                 return HttpResponse(
                     success=True,
                     message=f"错误处理报送已处理: {request_data['error_type']} - {request_data['error_message']}",
                     acknowledgment_id=f"ERROR_{int(time.time() * 1000)}_{request_data.get('action_id', 'unknown')}",
                     data=result
                 )
-
+                
         except Exception as e:
             logger.error(f"处理错误处理报送失败: {e}")
             return HttpResponse(
                 success=False,
                 message=f"错误处理报送处理失败: {str(e)}"
             )
-
+    
     def _handle_status_check(self) -> HttpResponse:
         """处理状态查询"""
         try:
-            # 安全地获取 device_id
-            device_id = "unknown"
-            if hasattr(self.workstation, 'device_id'):
-                device_id = self.workstation.device_id
-            elif hasattr(self.workstation, '_ros_node') and hasattr(self.workstation._ros_node, 'device_id'):
-                device_id = self.workstation._ros_node.device_id
-
             return HttpResponse(
                 success=True,
                 message="工作站报送服务正常运行",
                 data={
-                    "workstation_id": device_id,
+                    "workstation_id": self.workstation.device_id,
                     "service_type": "unified_reporting_service",
                     "uptime": time.time() - getattr(self.workstation, '_start_time', time.time()),
                     "reports_received": getattr(self.workstation, '_reports_received_count', 0),
                     "supported_endpoints": [
                         "POST /report/step_finish",
-                        "POST /report/sample_finish",
+                        "POST /report/sample_finish", 
                         "POST /report/order_finish",
                         "POST /report/batch_update",
                         "POST /report/material_change",
                         "POST /report/error_handling",
-                        "POST /report/temperature-cutoff",
                         "GET /status",
                         "GET /health"
                     ]
@@ -583,52 +514,36 @@ class WorkstationHTTPHandler(BaseHTTPRequestHandler):
                 success=False,
                 message=f"状态查询失败: {str(e)}"
             )
-
+    
     def _send_response(self, response: HttpResponse):
         """发送响应"""
         try:
             # 设置响应状态码
             status_code = 200 if response.success else 400
             self.send_response(status_code)
-
+            
             # 设置响应头
             self.send_header('Content-Type', 'application/json; charset=utf-8')
             self.send_header('Access-Control-Allow-Origin', '*')
             self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
             self.send_header('Access-Control-Allow-Headers', 'Content-Type')
             self.end_headers()
-
+            
             # 发送响应体
             response_json = json.dumps(asdict(response), ensure_ascii=False, indent=2)
             self.wfile.write(response_json.encode('utf-8'))
-
+            
         except Exception as e:
             logger.error(f"发送响应失败: {e}")
-
+    
     def log_message(self, format, *args):
         """重写日志方法"""
         logger.debug(f"HTTP请求: {format % args}")
 
-    def _save_raw_request(self, endpoint: str, request_data: Dict[str, Any]) -> None:
-        try:
-            base_dir = Path(__file__).resolve().parents[3] / "unilabos_data" / "http_reports"
-            base_dir.mkdir(parents=True, exist_ok=True)
-            log_path = getattr(self.workstation, "_http_log_path", None)
-            log_file = Path(log_path) if log_path else (base_dir / f"http_{int(time.time()*1000)}.log")
-            payload = {
-                "endpoint": endpoint,
-                "received_at": datetime.now().isoformat(),
-                "body": request_data
-            }
-            with open(log_file, "a", encoding="utf-8") as f:
-                f.write(json.dumps(payload, ensure_ascii=False) + "\n")
-        except Exception:
-            pass
-
 
 class WorkstationHTTPService:
     """工作站HTTP服务"""
-
+    
     def __init__(self, workstation_instance, host: str = "127.0.0.1", port: int = 8080):
         self.workstation = workstation_instance
         self.host = host
@@ -636,42 +551,31 @@ class WorkstationHTTPService:
         self.server = None
         self.server_thread = None
         self.running = False
-
+        
         # 初始化统计信息
         self.workstation._start_time = time.time()
         self.workstation._reports_received_count = 0
-
+    
     def start(self):
         """启动HTTP服务"""
         try:
             # 创建处理器工厂函数
             def handler_factory(*args, **kwargs):
                 return WorkstationHTTPHandler(self.workstation, *args, **kwargs)
-
+            
             # 创建HTTP服务器
             self.server = HTTPServer((self.host, self.port), handler_factory)
-            base_dir = Path(__file__).resolve().parents[3] / "unilabos_data" / "http_reports"
-            base_dir.mkdir(parents=True, exist_ok=True)
-            session_log = base_dir / f"http_{int(time.time()*1000)}.log"
-            setattr(self.workstation, "_http_log_path", str(session_log))
-
-            # 安全地获取 device_id 用于线程命名
-            device_id = "unknown"
-            if hasattr(self.workstation, 'device_id'):
-                device_id = self.workstation.device_id
-            elif hasattr(self.workstation, '_ros_node') and hasattr(self.workstation._ros_node, 'device_id'):
-                device_id = self.workstation._ros_node.device_id
-
+            
             # 在单独线程中运行服务器
             self.server_thread = threading.Thread(
                 target=self._run_server,
                 daemon=True,
-                name=f"WorkstationHTTP-{device_id}"
+                name=f"WorkstationHTTP-{self.workstation.device_id}"
             )
-
+            
             self.running = True
             self.server_thread.start()
-
+            
             logger.info(f"工作站HTTP报送服务已启动: http://{self.host}:{self.port}")
             logger.info("统一的报送端点 (基于LIMS协议规范):")
             logger.info("  - POST /report/step_finish    # 步骤完成报送")
@@ -681,7 +585,6 @@ class WorkstationHTTPService:
             logger.info("扩展报送端点:")
             logger.info("  - POST /report/material_change # 物料变更报送")
             logger.info("  - POST /report/error_handling  # 错误处理报送")
-            logger.info("  - POST /report/temperature-cutoff # 温度/粘度报送")
             logger.info("兼容端点:")
             logger.info("  - POST /LIMS/step_finish      # 兼容LIMS步骤完成")
             logger.info("  - POST /LIMS/preintake_finish # 兼容LIMS通量完成")
@@ -689,33 +592,33 @@ class WorkstationHTTPService:
             logger.info("服务端点:")
             logger.info("  - GET  /status                # 服务状态查询")
             logger.info("  - GET  /health                # 健康检查")
-
+            
         except Exception as e:
             logger.error(f"启动HTTP服务失败: {e}")
             raise
-
+    
     def stop(self):
         """停止HTTP服务"""
         try:
             if self.running and self.server:
                 logger.info("正在停止工作站HTTP报送服务...")
                 self.running = False
-
+                
                 # 停止serve_forever循环
                 self.server.shutdown()
-
+                
                 # 等待服务器线程结束
                 if self.server_thread and self.server_thread.is_alive():
                     self.server_thread.join(timeout=5.0)
-
+                
                 # 关闭服务器套接字
                 self.server.server_close()
-
+                
                 logger.info("工作站HTTP报送服务已停止")
-
+                
         except Exception as e:
             logger.error(f"停止HTTP服务失败: {e}")
-
+    
     def _run_server(self):
         """运行HTTP服务器"""
         try:
@@ -726,12 +629,12 @@ class WorkstationHTTPService:
                 logger.error(f"HTTP服务运行错误: {e}")
         finally:
             logger.info("HTTP服务器线程已退出")
-
+    
     @property
     def is_running(self) -> bool:
         """检查服务是否正在运行"""
         return self.running and self.server_thread and self.server_thread.is_alive()
-
+    
     @property
     def service_url(self) -> str:
         """获取服务URL"""
@@ -745,7 +648,7 @@ class MaterialChangeReport:
     pass
 
 
-@dataclass
+@dataclass 
 class TaskExecutionReport:
     """已废弃：任务执行报送，请使用统一的WorkstationReportRequest"""
     pass
@@ -765,43 +668,40 @@ __all__ = [
 
 if __name__ == "__main__":
     # 简单测试HTTP服务
-    class BioyondWorkstation:
+    class DummyWorkstation:
         device_id = "WS-001"
-
+        
         def process_step_finish_report(self, report_request):
             return {"processed": True}
-
+        
         def process_sample_finish_report(self, report_request):
             return {"processed": True}
-
+        
         def process_order_finish_report(self, report_request, used_materials):
             return {"processed": True}
-
+        
         def process_material_change_report(self, report_data):
             return {"processed": True}
-
+        
         def handle_external_error(self, error_data):
             return {"handled": True}
-
-        def process_temperature_cutoff_report(self, report_request):
-            return {"processed": True, "metrics": report_request.data}
-
-    workstation = BioyondWorkstation()
+    
+    workstation = DummyWorkstation()
     http_service = WorkstationHTTPService(workstation)
-
+    
     try:
         http_service.start()
         print(f"测试服务器已启动: {http_service.service_url}")
         print("按 Ctrl+C 停止服务器")
         print("服务将持续运行，等待接收HTTP请求...")
-
+        
         # 保持服务器运行 - 使用更好的等待机制
         try:
             while http_service.is_running:
                 time.sleep(1)
         except KeyboardInterrupt:
             print("\n接收到停止信号...")
-
+            
     except KeyboardInterrupt:
         print("\n正在停止服务器...")
         http_service.stop()
@@ -809,3 +709,4 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"服务器运行错误: {e}")
         http_service.stop()
+

unilabos/registry/devices/bioyond.yaml

@@ -1,395 +0,0 @@
-workstation.bioyond_dispensing_station:
-  category:
-  - workstation
-  - bioyond
-  class:
-    action_value_mappings:
-      auto-batch_create_90_10_vial_feeding_tasks:
-        feedback: {}
-        goal: {}
-        goal_default:
-          delay_time: null
-          hold_m_name: null
-          liquid_material_name: NMP
-          speed: null
-          temperature: null
-          titration: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                delay_time:
-                  type: string
-                hold_m_name:
-                  type: string
-                liquid_material_name:
-                  default: NMP
-                  type: string
-                speed:
-                  type: string
-                temperature:
-                  type: string
-                titration:
-                  type: string
-              required:
-              - titration
-              type: object
-            result: {}
-          required:
-          - goal
-          title: batch_create_90_10_vial_feeding_tasks参数
-          type: object
-        type: UniLabJsonCommand
-      auto-batch_create_diamine_solution_tasks:
-        feedback: {}
-        goal: {}
-        goal_default:
-          delay_time: null
-          liquid_material_name: NMP
-          solutions: null
-          speed: null
-          temperature: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                delay_time:
-                  type: string
-                liquid_material_name:
-                  default: NMP
-                  type: string
-                solutions:
-                  type: string
-                speed:
-                  type: string
-                temperature:
-                  type: string
-              required:
-              - solutions
-              type: object
-            result: {}
-          required:
-          - goal
-          title: batch_create_diamine_solution_tasks参数
-          type: object
-        type: UniLabJsonCommand
-      auto-process_order_finish_report:
-        feedback: {}
-        goal: {}
-        goal_default:
-          report_request: null
-          used_materials: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                report_request:
-                  type: string
-                used_materials:
-                  type: string
-              required:
-              - report_request
-              - used_materials
-              type: object
-            result: {}
-          required:
-          - goal
-          title: process_order_finish_report参数
-          type: object
-        type: UniLabJsonCommand
-      auto-wait_for_multiple_orders_and_get_reports:
-        feedback: {}
-        goal: {}
-        goal_default:
-          batch_create_result: null
-          check_interval: 10
-          timeout: 7200
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                batch_create_result:
-                  type: string
-                check_interval:
-                  default: 10
-                  type: integer
-                timeout:
-                  default: 7200
-                  type: integer
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: wait_for_multiple_orders_and_get_reports参数
-          type: object
-        type: UniLabJsonCommand
-      create_90_10_vial_feeding_task:
-        feedback: {}
-        goal:
-          delay_time: delay_time
-          hold_m_name: hold_m_name
-          order_name: order_name
-          percent_10_1_assign_material_name: percent_10_1_assign_material_name
-          percent_10_1_liquid_material_name: percent_10_1_liquid_material_name
-          percent_10_1_target_weigh: percent_10_1_target_weigh
-          percent_10_1_volume: percent_10_1_volume
-          percent_10_2_assign_material_name: percent_10_2_assign_material_name
-          percent_10_2_liquid_material_name: percent_10_2_liquid_material_name
-          percent_10_2_target_weigh: percent_10_2_target_weigh
-          percent_10_2_volume: percent_10_2_volume
-          percent_10_3_assign_material_name: percent_10_3_assign_material_name
-          percent_10_3_liquid_material_name: percent_10_3_liquid_material_name
-          percent_10_3_target_weigh: percent_10_3_target_weigh
-          percent_10_3_volume: percent_10_3_volume
-          percent_90_1_assign_material_name: percent_90_1_assign_material_name
-          percent_90_1_target_weigh: percent_90_1_target_weigh
-          percent_90_2_assign_material_name: percent_90_2_assign_material_name
-          percent_90_2_target_weigh: percent_90_2_target_weigh
-          percent_90_3_assign_material_name: percent_90_3_assign_material_name
-          percent_90_3_target_weigh: percent_90_3_target_weigh
-          speed: speed
-          temperature: temperature
-        goal_default:
-          delay_time: ''
-          hold_m_name: ''
-          order_name: ''
-          percent_10_1_assign_material_name: ''
-          percent_10_1_liquid_material_name: ''
-          percent_10_1_target_weigh: ''
-          percent_10_1_volume: ''
-          percent_10_2_assign_material_name: ''
-          percent_10_2_liquid_material_name: ''
-          percent_10_2_target_weigh: ''
-          percent_10_2_volume: ''
-          percent_10_3_assign_material_name: ''
-          percent_10_3_liquid_material_name: ''
-          percent_10_3_target_weigh: ''
-          percent_10_3_volume: ''
-          percent_90_1_assign_material_name: ''
-          percent_90_1_target_weigh: ''
-          percent_90_2_assign_material_name: ''
-          percent_90_2_target_weigh: ''
-          percent_90_3_assign_material_name: ''
-          percent_90_3_target_weigh: ''
-          speed: ''
-          temperature: ''
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties: {}
-              required: []
-              title: DispenStationVialFeed_Feedback
-              type: object
-            goal:
-              properties:
-                delay_time:
-                  type: string
-                hold_m_name:
-                  type: string
-                order_name:
-                  type: string
-                percent_10_1_assign_material_name:
-                  type: string
-                percent_10_1_liquid_material_name:
-                  type: string
-                percent_10_1_target_weigh:
-                  type: string
-                percent_10_1_volume:
-                  type: string
-                percent_10_2_assign_material_name:
-                  type: string
-                percent_10_2_liquid_material_name:
-                  type: string
-                percent_10_2_target_weigh:
-                  type: string
-                percent_10_2_volume:
-                  type: string
-                percent_10_3_assign_material_name:
-                  type: string
-                percent_10_3_liquid_material_name:
-                  type: string
-                percent_10_3_target_weigh:
-                  type: string
-                percent_10_3_volume:
-                  type: string
-                percent_90_1_assign_material_name:
-                  type: string
-                percent_90_1_target_weigh:
-                  type: string
-                percent_90_2_assign_material_name:
-                  type: string
-                percent_90_2_target_weigh:
-                  type: string
-                percent_90_3_assign_material_name:
-                  type: string
-                percent_90_3_target_weigh:
-                  type: string
-                speed:
-                  type: string
-                temperature:
-                  type: string
-              required:
-              - order_name
-              - percent_90_1_assign_material_name
-              - percent_90_1_target_weigh
-              - percent_90_2_assign_material_name
-              - percent_90_2_target_weigh
-              - percent_90_3_assign_material_name
-              - percent_90_3_target_weigh
-              - percent_10_1_assign_material_name
-              - percent_10_1_target_weigh
-              - percent_10_1_volume
-              - percent_10_1_liquid_material_name
-              - percent_10_2_assign_material_name
-              - percent_10_2_target_weigh
-              - percent_10_2_volume
-              - percent_10_2_liquid_material_name
-              - percent_10_3_assign_material_name
-              - percent_10_3_target_weigh
-              - percent_10_3_volume
-              - percent_10_3_liquid_material_name
-              - speed
-              - temperature
-              - delay_time
-              - hold_m_name
-              title: DispenStationVialFeed_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-              required:
-              - return_info
-              title: DispenStationVialFeed_Result
-              type: object
-          required:
-          - goal
-          title: DispenStationVialFeed
-          type: object
-        type: DispenStationVialFeed
-      create_diamine_solution_task:
-        feedback: {}
-        goal:
-          delay_time: delay_time
-          hold_m_name: hold_m_name
-          liquid_material_name: liquid_material_name
-          material_name: material_name
-          order_name: order_name
-          speed: speed
-          target_weigh: target_weigh
-          temperature: temperature
-          volume: volume
-        goal_default:
-          delay_time: ''
-          hold_m_name: ''
-          liquid_material_name: ''
-          material_name: ''
-          order_name: ''
-          speed: ''
-          target_weigh: ''
-          temperature: ''
-          volume: ''
-        handles: {}
-        result:
-          return_info: return_info
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties: {}
-              required: []
-              title: DispenStationSolnPrep_Feedback
-              type: object
-            goal:
-              properties:
-                delay_time:
-                  type: string
-                hold_m_name:
-                  type: string
-                liquid_material_name:
-                  type: string
-                material_name:
-                  type: string
-                order_name:
-                  type: string
-                speed:
-                  type: string
-                target_weigh:
-                  type: string
-                temperature:
-                  type: string
-                volume:
-                  type: string
-              required:
-              - order_name
-              - material_name
-              - target_weigh
-              - volume
-              - liquid_material_name
-              - speed
-              - temperature
-              - delay_time
-              - hold_m_name
-              title: DispenStationSolnPrep_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-              required:
-              - return_info
-              title: DispenStationSolnPrep_Result
-              type: object
-          required:
-          - goal
-          title: DispenStationSolnPrep
-          type: object
-        type: DispenStationSolnPrep
-    module: unilabos.devices.workstation.bioyond_studio.dispensing_station:BioyondDispensingStation
-    status_types: {}
-    type: python
-  config_info: []
-  description: ''
-  handles: []
-  icon: ''
-  init_param_schema:
-    config:
-      properties:
-        config:
-          type: string
-        deck:
-          type: string
-      required:
-      - config
-      - deck
-      type: object
-    data:
-      properties: {}
-      required: []
-      type: object
-  version: 1.0.0