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

扣电驱动中增加多个组装参数，elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200，更新驱动与注册表

.conda/recipe.yaml

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

.gitignore

@@ -246,3 +246,5 @@ local_test2.py
 ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
 *.bz2
 test_config.py
+
+

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

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

docs/developer_guide/add_action.md

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

docs/developer_guide/workstation_architecture.md

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

docs/user_guide/installation.md

@@ -14,13 +14,30 @@ mamba create -n unilab uni-lab::unilabos -c robostack-staging -c conda-forge
 
 ```shell
 # 配置好conda环境后，克隆仓库
-git clone https://github.com/dptech-corp/Uni-Lab-OS.git
+git clone https://github.com/dptech-corp/Uni-Lab-OS.git -b dev
 cd Uni-Lab-OS
 
 # 安装 Uni-Lab-OS
-pip install .
+pip install -e .
 ```
 
-3. **启动 Uni-Lab 系统**
+3. **安装开发版 ros-humble-unilabos-msgs**
+
+**卸载老版本：**
+```shell
+conda activate unilab
+conda remove --force ros-humble-unilabos-msgs
+```
+有时相同的安装包版本会由于dev构建得到的md5不一样，触发安全检查，可输入 `config set safety_checks disabled` 来关闭安全检查。
+
+**安装新版本：**
+
+访问 https://github.com/dptech-corp/Uni-Lab-OS/actions/workflows/multi-platform-build.yml 选择最新的构建，下载对应平台的压缩包（仅解压一次，得到.conda文件）使用如下指令：
+```shell
+conda activate base
+conda install ros-humble-unilabos-msgs-<version>-<platform>.conda --offline -n <环境名>
+```
+
+4. **启动 Uni-Lab 系统**
 
 请参见{doc}`启动样例 <../boot_examples/index>`或{doc}`启动指南 <launch>`了解详细的启动方法。

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

setup.py

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

test/experiments/dispensing_station_bioyond.json

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

test/experiments/reaction_station_bioyond.json

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

test/experiments/reaction_station_bioyond_test.json

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

test/resources/bioyond_materials.json

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

test/resources/test_bottle_carrier.py

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

test/resources/test_converter_bioyond.py

@@ -0,0 +1,35 @@
+import pytest
+import json
+import os
+
+from unilabos.resources.graphio import resource_bioyond_to_plr
+from unilabos.registry.registry import lab_registry
+
+from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
+
+lab_registry.setup()
+
+
+type_mapping = {
+    "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
+    "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
+    "样品板": "BIOYOND_PolymerStation_6VialCarrier",
+}
+
+@pytest.fixture
+def bioyond_materials() -> list[dict]:
+    print("加载 BioYond 物料数据...")
+    print(os.getcwd())
+    with open("bioyond_materials.json", "r", encoding="utf-8") as f:
+        data = json.load(f)["data"]
+    print(f"加载了 {len(data)} 条物料数据")
+    return data
+
+
+def test_bioyond_to_plr(bioyond_materials) -> list[dict]:
+    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
+    print("将 BioYond 物料数据转换为 PLR 格式...")
+    output = resource_bioyond_to_plr(bioyond_materials, type_mapping=type_mapping, deck=deck)
+    print(deck.summary())
+    print([resource.serialize() for resource in output])
+    print([resource.serialize_all_state() for resource in output])

unilabos-linux-64.yaml

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

unilabos-osx-64.yaml

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

unilabos-osx-arm64.yaml

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

unilabos-win64.yaml

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

unilabos/app/web/client.py

@@ -25,6 +25,7 @@ class HTTPClient:
             remote_addr: 远程服务器地址，如果不提供则从配置中获取
             auth: 授权信息
         """
+        self.initialized = False
         self.remote_addr = remote_addr or HTTPConfig.remote_addr
         if auth is not None:
             self.auth = auth
@@ -34,7 +35,7 @@ class HTTPClient:
             info(f"正在使用ak sk作为授权信息：[{auth_secret}]")
         info(f"HTTPClient 初始化完成: remote_addr={self.remote_addr}")
 
-    def resource_edge_add(self, resources: List[Dict[str, Any]], database_process_later: bool) -> requests.Response:
+    def resource_edge_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
         """
         添加资源
 
@@ -60,22 +61,31 @@ class HTTPClient:
             logger.error(f"添加物料关系失败: {response.status_code}, {response.text}")
         return response
 
-    def resource_add(self, resources: List[Dict[str, Any]], database_process_later: bool) -> requests.Response:
+    def resource_add(self, resources: List[Dict[str, Any]]) -> requests.Response:
         """
         添加资源
 
         Args:
             resources: 要添加的资源列表
-            database_process_later: 后台处理资源
         Returns:
             Response: API响应对象
         """
-        response = requests.post(
-            f"{self.remote_addr}/lab/material",
-            json={"nodes": resources},
-            headers={"Authorization": f"Lab {self.auth}"},
-            timeout=100,
-        )
+        if not self.initialized:
+            self.initialized = True
+            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
+            response = requests.post(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        else:
+            response = requests.put(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
         if response.status_code == 200:
             res = response.json()
             if "code" in res and res["code"] != 0:
@@ -131,14 +141,29 @@ class HTTPClient:
         Returns:
             Response: API响应对象
         """
-        return self.resource_add(resources)
-        response = requests.patch(
-            f"{self.remote_addr}/lab/resource/batch_update/?edge_format=1",
-            json=resources,
-            headers={"Authorization": f"Lab {self.auth}"},
-            timeout=100,
-        )
-        return response
+        if not self.initialized:
+            self.initialized = True
+            info(f"首次添加资源，当前远程地址: {self.remote_addr}")
+            response = requests.post(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        else:
+            response = requests.put(
+                f"{self.remote_addr}/lab/material",
+                json={"nodes": resources},
+                headers={"Authorization": f"Lab {self.auth}"},
+                timeout=100,
+            )
+        if response.status_code == 200:
+            res = response.json()
+            if "code" in res and res["code"] != 0:
+                logger.error(f"添加物料失败: {response.text}")
+        if response.status_code != 200:
+            logger.error(f"添加物料失败: {response.text}")
+        return response.json()
 
     def upload_file(self, file_path: str, scene: str = "models") -> requests.Response:
         """

unilabos/compile/add_protocol.py

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

unilabos/compile/adjustph_protocol.py

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

unilabos/compile/centrifuge_protocol.py

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

unilabos/compile/clean_vessel_protocol.py

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

unilabos/compile/dissolve_protocol.py

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

unilabos/compile/dry_protocol.py

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

unilabos/compile/evacuateandrefill_protocol.py

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

unilabos/compile/evaporate_protocol.py

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

unilabos/compile/heatchill_protocol.py

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

unilabos/compile/separate_protocol.py

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

unilabos/compile/stir_protocol.py

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

unilabos/compile/wash_solid_protocol.py

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

unilabos/device_comms/coin_cell_assembly_workstation.py

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

unilabos/device_comms/modbus_plc/client.py

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

unilabos/device_comms/modbus_plc/test/client.py

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

unilabos/device_comms/modbus_plc/test/node_test.py

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

unilabos/device_comms/modbus_plc/test/test_workflow.py

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

unilabos/devices/balance/__init__.py

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

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

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

unilabos/devices/balance/mettler_toledo_xpr/Mettler_Toledo_Balance_ROS2_User_Guide.md

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

unilabos/devices/balance/mettler_toledo_xpr/README.md

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

unilabos/devices/balance/mettler_toledo_xpr/__init__.py

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

unilabos/devices/balance/mettler_toledo_xpr/balance.yaml

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

unilabos/devices/balance/mettler_toledo_xpr/balance_test.json

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

unilabos/devices/balance/mettler_toledo_xpr/mettler_toledo_xpr.py

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

unilabos/devices/battery/battery.json

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

unilabos/devices/virtual/virtual_solid_dispenser.py

@@ -288,7 +288,7 @@ class VirtualSolidDispenser:
                 "return_info": f"dispensed_{actual_amount:.6f}g",
                 "dispensed_amount": actual_amount,
                 "reagent": reagent,
-                "vessel": vessel
+                "vessel": {"id": vessel},
             }
             
         except Exception as e:

unilabos/devices/workstation/README.md

@@ -0,0 +1,184 @@
+# 工作站抽象基类物料系统架构说明
+
+## 设计理念
+
+基于用户需求"请你帮我系统思考一下，工作站抽象基类的物料系统基类该如何构建"，我们最终确定了一个**PyLabRobot Deck为中心**的简化架构。
+
+### 核心原则
+
+1. **PyLabRobot为物料管理核心**：使用PyLabRobot的Deck系统作为物料管理的基础，利用其成熟的Resource体系
+2. **Graphio转换函数集成**：使用graphio中的`resource_ulab_to_plr`等转换函数实现UniLab与PLR格式的无缝转换
+3. **关注点分离**：基类专注核心物料系统，HTTP服务等功能在子类中实现
+4. **外部系统集成模式**：通过ResourceSynchronizer抽象类提供外部物料系统对接模式
+
+## 架构组成
+
+### 1. WorkstationBase（基类）
+**文件**: `workstation_base.py`
+
+**核心功能**：
+- 使用deck_config和children通过`resource_ulab_to_plr`转换为PLR物料self.deck
+- 基础的资源查找和管理功能
+- 抽象的工作流执行接口
+- ResourceSynchronizer集成点
+
+**关键代码**：
+```python
+def _initialize_material_system(self, deck_config: Dict[str, Any], children_config: Dict[str, Any] = None):
+    """初始化基于PLR的物料系统"""
+    # 合并deck_config和children
+    complete_config = self._merge_deck_and_children_config(deck_config, children_config)
+    
+    # 使用graphio转换函数转换为PLR资源
+    self.deck = resource_ulab_to_plr(complete_config)
+```
+
+### 2. ResourceSynchronizer（外部系统集成抽象类）
+**定义在**: `workstation_base.py`
+
+**设计目的**：
+- 提供外部物料系统（如Bioyong、LIMS等）集成的标准接口
+- 双向同步：从外部系统同步到本地deck，以及将本地变更同步到外部系统
+- 处理外部系统的变更通知
+
+**核心方法**：
+```python
+async def sync_from_external(self) -> bool:
+    """从外部系统同步物料到本地deck"""
+    
+async def sync_to_external(self, plr_resource) -> bool:
+    """将本地物料同步到外部系统"""
+    
+async def handle_external_change(self, change_info: Dict[str, Any]) -> bool:
+    """处理外部系统的变更通知"""
+```
+
+### 3. WorkstationWithHTTP（子类示例）
+**文件**: `workstation_with_http_example.py`
+
+**扩展功能**：
+- HTTP报送接收服务集成
+- 具体工作流实现（液体转移、板洗等）
+- Bioyong物料系统同步器示例
+- 外部报送处理方法
+
+## 技术栈
+
+### 核心依赖
+- **PyLabRobot**: 物料资源管理核心（Deck, Resource, Coordinate）
+- **GraphIO转换函数**: UniLab ↔ PLR格式转换
+  - `resource_ulab_to_plr`: UniLab格式转PLR格式
+  - `resource_plr_to_ulab`: PLR格式转UniLab格式
+  - `convert_resources_to_type`: 通用资源类型转换
+- **ROS2**: 基础设备节点通信（BaseROS2DeviceNode）
+
+### 可选依赖
+- **HTTP服务**: 仅在需要外部报送接收的子类中使用
+- **外部系统API**: 根据具体集成需求添加
+
+## 使用示例
+
+### 1. 简单工作站（仅PLR物料系统）
+
+```python
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+
+# Deck配置
+deck_config = {
+    "size_x": 1200.0,
+    "size_y": 800.0,
+    "size_z": 100.0
+}
+
+# 子资源配置
+children_config = {
+    "source_plate": {
+        "name": "source_plate",
+        "type": "plate",
+        "position": {"x": 100, "y": 100, "z": 10},
+        "config": {"size_x": 127.8, "size_y": 85.5, "size_z": 14.4}
+    }
+}
+
+# 创建工作站
+workstation = WorkstationBase(
+    device_id="simple_workstation",
+    deck_config=deck_config,
+    children_config=children_config
+)
+
+# 查找资源
+plate = workstation.find_resource_by_name("source_plate")
+```
+
+### 2. 带HTTP服务的工作站
+
+```python
+from unilabos.devices.workstation.workstation_with_http_example import WorkstationWithHTTP
+
+# HTTP服务配置
+http_service_config = {
+    "enabled": True,
+    "host": "127.0.0.1",
+    "port": 8081
+}
+
+# 创建带HTTP服务的工作站
+workstation = WorkstationWithHTTP(
+    device_id="http_workstation",
+    deck_config=deck_config,
+    children_config=children_config,
+    http_service_config=http_service_config
+)
+
+# 执行工作流
+success = workstation.execute_workflow("liquid_transfer", {
+    "volume": 100.0,
+    "source_wells": ["A1", "A2"],
+    "dest_wells": ["B1", "B2"]
+})
+```
+
+### 3. 外部系统集成
+
+```python
+class BioyongResourceSynchronizer(ResourceSynchronizer):
+    """Bioyong系统同步器"""
+    
+    async def sync_from_external(self) -> bool:
+        # 从Bioyong API获取物料
+        external_materials = await self._fetch_bioyong_materials()
+        
+        # 转换并添加到本地deck
+        for material in external_materials:
+            await self._add_material_to_deck(material)
+        
+        return True
+```
+
+## 设计优势
+
+### 1. **简洁性**
+- 基类只专注核心物料管理，没有冗余功能
+- 使用成熟的PyLabRobot作为物料管理基础
+
+### 2. **可扩展性**
+- 通过子类添加HTTP服务、特定工作流等功能
+- ResourceSynchronizer模式支持任意外部系统集成
+
+### 3. **标准化**
+- PLR Deck提供标准的资源管理接口
+- Graphio转换函数确保格式一致性
+
+### 4. **灵活性**
+- 可选择性使用HTTP服务和外部系统集成
+- 支持不同类型的工作站需求
+
+## 发展历程
+
+1. **初始设计**: 复杂的统一物料系统，包含HTTP服务和多种功能
+2. **PyLabRobot集成**: 引入PLR Deck管理，但保留了ResourceTracker复杂性
+3. **Graphio转换**: 使用graphio转换函数简化初始化
+4. **最终简化**: 专注核心PLR物料系统，HTTP服务移至子类
+
+这个架构体现了"用PyLabRobot Deck来管理物料会更好；但是要做好和外部物料系统的对接"的设计理念，以及"现在我只需要在工作站创建的时候，整体使用deck_config和children，一起通过resource_ulab_to_plr转换为plr物料self.deck即可"的简化要求。

unilabos/devices/workstation/bioyond_cell/benyao_test.py

@@ -0,0 +1,49 @@
+import requests
+import json
+from datetime import datetime
+def test_benyao_api():
+    # 配置信息
+    ip_addr = "192.168.1.200"
+    port = 44386
+    #url = f"http://{ip_addr}:{port}/api/lims/scheduler/scheduler-status"
+    #url = f"http://{ip_addr}:{port}/api/lims/order/order-list-status"
+    url = f"http://{ip_addr}:{port}/api/lims/storage/stock-material"
+    apiKey = "8A819E5C"  # 请替换为实际apiKey
+    
+    # 构造请求体
+    request_data = {
+        "apiKey": apiKey,
+        "requestTime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),  # 示例：2025-08-15T10:00:00.000Z
+        "data": {
+                "typeMode": 1,
+                "includeDetail": True
+            }
+    
+    }
+    
+    #request_data = {
+    #    "apiKey": apiKey,
+    #    "requestTime": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),  # 示例：2025-08-15T10:00:00.000Z
+    #    "data": 
+    #}
+    
+    
+    print(request_data)
+    # 发送POST请求
+    try:
+        response = requests.post(url, json=request_data, timeout=10)
+        response.raise_for_status()  # 检查HTTP状态码
+    
+        # 解析响应
+        result = response.json()
+        print("响应状态码:", response.status_code)
+        print("响应内容:")
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    
+    except requests.exceptions.RequestException as e:
+        print("请求失败:", e)
+    except json.JSONDecodeError as e:
+        print("JSON解析失败:", e)
+    
+if __name__ == "__main__":
+    test_benyao_api()

unilabos/devices/workstation/bioyond_cell/bioyond_material_management.py

@@ -0,0 +1,374 @@
+"""
+Bioyond物料管理实现
+Bioyond Material Management Implementation
+
+基于Bioyond系统的物料管理，支持从Bioyond系统同步物料到UniLab工作站
+"""
+from typing import Dict, Any, List, Optional, Union
+import json
+import asyncio
+from abc import ABC, abstractmethod
+
+from pylabrobot.resources import (
+    Resource as PLRResource,
+    Container,
+    Deck,
+    Coordinate as PLRCoordinate,
+)
+
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
+from unilabos.utils.log import logger
+from unilabos.resources.graphio import (
+    resource_plr_to_ulab, 
+    resource_ulab_to_plr,
+    resource_bioyond_to_ulab,
+    resource_bioyond_container_to_ulab,
+    resource_ulab_to_bioyond
+)
+from .workstation_material_management import MaterialManagementBase
+
+
+class BioyondMaterialManagement(MaterialManagementBase):
+    """Bioyond物料管理类
+    
+    实现从Bioyond系统同步物料到UniLab工作站的功能：
+    1. 从Bioyond系统获取物料数据
+    2. 转换为UniLab格式
+    3. 同步到PyLabRobot Deck
+    4. 支持双向同步
+    """
+    
+    def __init__(
+        self,
+        device_id: str,
+        deck_config: Dict[str, Any],
+        resource_tracker: DeviceNodeResourceTracker,
+        children_config: Dict[str, Dict[str, Any]] = None,
+        bioyond_config: Dict[str, Any] = None
+    ):
+        self.bioyond_config = bioyond_config or {}
+        self.bioyond_api_client = None
+        self.sync_interval = self.bioyond_config.get("sync_interval", 30)  # 同步间隔（秒）
+        
+        # 初始化父类
+        super().__init__(device_id, deck_config, resource_tracker, children_config)
+        
+        # 初始化Bioyond API客户端
+        self._initialize_bioyond_client()
+        
+        # 启动同步任务
+        self._start_sync_task()
+    
+    def _initialize_bioyond_client(self):
+        """初始化Bioyond API客户端"""
+        try:
+            # 这里应该根据实际的Bioyond API实现
+            # 暂时使用模拟客户端
+            self.bioyond_api_client = BioyondAPIClient(self.bioyond_config)
+            logger.info(f"Bioyond API客户端初始化成功")
+        except Exception as e:
+            logger.error(f"Bioyond API客户端初始化失败: {e}")
+            self.bioyond_api_client = None
+    
+    def _start_sync_task(self):
+        """启动同步任务"""
+        if self.bioyond_api_client:
+            # 创建异步同步任务
+            asyncio.create_task(self._periodic_sync())
+            logger.info(f"Bioyond同步任务已启动，间隔: {self.sync_interval}秒")
+    
+    async def _periodic_sync(self):
+        """定期同步任务"""
+        while True:
+            try:
+                await self.sync_from_bioyond()
+                await asyncio.sleep(self.sync_interval)
+            except Exception as e:
+                logger.error(f"Bioyond同步任务出错: {e}")
+                await asyncio.sleep(self.sync_interval)
+    
+    async def sync_from_bioyond(self) -> bool:
+        """从Bioyond系统同步物料"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 从Bioyond获取物料数据
+            bioyond_data = await self.bioyond_api_client.get_materials()
+            if not bioyond_data:
+                logger.warning("从Bioyond获取物料数据为空")
+                return False
+            
+            # 2. 转换为UniLab格式
+            if isinstance(bioyond_data, dict) and "data" in bioyond_data:
+                # 容器格式数据
+                unilab_resources = resource_bioyond_container_to_ulab(bioyond_data)
+            else:
+                # 物料列表格式数据
+                unilab_resources = resource_bioyond_to_ulab(bioyond_data)
+            
+            # 3. 转换为PLR格式并分配到Deck
+            await self._assign_resources_to_deck(unilab_resources)
+            
+            logger.info(f"从Bioyond同步了 {len(unilab_resources)} 个资源")
+            return True
+            
+        except Exception as e:
+            logger.error(f"从Bioyond同步物料失败: {e}")
+            return False
+    
+    async def sync_to_bioyond(self, plr_resource: PLRResource) -> bool:
+        """将本地物料变更同步到Bioyond系统"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 转换为UniLab格式
+            unilab_resource = resource_plr_to_ulab(plr_resource)
+            
+            # 2. 转换为Bioyond格式
+            bioyond_materials = resource_ulab_to_bioyond([unilab_resource])
+            
+            # 3. 发送到Bioyond系统
+            success = await self.bioyond_api_client.update_materials(bioyond_materials)
+            
+            if success:
+                logger.info(f"成功同步物料 {plr_resource.name} 到Bioyond")
+            else:
+                logger.warning(f"同步物料 {plr_resource.name} 到Bioyond失败")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"同步物料到Bioyond失败: {e}")
+            return False
+    
+    async def _assign_resources_to_deck(self, unilab_resources: List[Dict[str, Any]]):
+        """将UniLab资源分配到Deck"""
+        try:
+            # 转换为PLR格式
+            from unilabos.resources.graphio import list_to_nested_dict
+            nested_resources = list_to_nested_dict(unilab_resources)
+            plr_resources = resource_ulab_to_plr(nested_resources)
+            
+            # 分配资源到Deck
+            if hasattr(plr_resources, 'children'):
+                resources_to_assign = plr_resources.children
+            elif isinstance(plr_resources, list):
+                resources_to_assign = plr_resources
+            else:
+                resources_to_assign = [plr_resources]
+            
+            for resource in resources_to_assign:
+                try:
+                    # 获取资源位置
+                    if hasattr(resource, 'location') and resource.location:
+                        location = PLRCoordinate(resource.location.x, resource.location.y, resource.location.z)
+                    else:
+                        location = PLRCoordinate(0, 0, 0)
+                    
+                    # 分配资源到Deck
+                    self.plr_deck.assign_child_resource(resource, location)
+                    
+                    # 注册到resource tracker
+                    self.resource_tracker.add_resource(resource)
+                    
+                    # 保存资源引用
+                    self.plr_resources[resource.name] = resource
+                    
+                except Exception as e:
+                    logger.error(f"分配资源 {resource.name} 到Deck失败: {e}")
+            
+            logger.info(f"成功分配了 {len(resources_to_assign)} 个资源到Deck")
+            
+        except Exception as e:
+            logger.error(f"分配资源到Deck失败: {e}")
+    
+    def _create_resource_by_type(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """根据类型创建Bioyond相关资源"""
+        try:
+            # 这里可以根据需要实现特定的Bioyond资源类型
+            # 目前使用通用的容器类型
+            if resource_type in ["container", "plate", "well"]:
+                return self._create_generic_container(resource_id, resource_type, config, data, location)
+            else:
+                logger.warning(f"未知的Bioyond资源类型: {resource_type}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"创建Bioyond资源失败 {resource_id} ({resource_type}): {e}")
+            return None
+    
+    def _create_generic_container(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """创建通用容器资源"""
+        try:
+            from pylabrobot.resources import Plate, Well
+            
+            if resource_type == "plate":
+                return Plate(
+                    name=resource_id,
+                    size_x=config.get("size_x", 127.76),
+                    size_y=config.get("size_y", 85.48),
+                    size_z=config.get("size_z", 14.35),
+                    location=location,
+                    category="plate"
+                )
+            elif resource_type == "well":
+                return Well(
+                    name=resource_id,
+                    size_x=config.get("size_x", 9.0),
+                    size_y=config.get("size_y", 9.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="well"
+                )
+            else:
+                return Container(
+                    name=resource_id,
+                    size_x=config.get("size_x", 50.0),
+                    size_y=config.get("size_y", 50.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="container"
+                )
+                
+        except Exception as e:
+            logger.error(f"创建通用容器失败 {resource_id}: {e}")
+            return None
+    
+    def get_bioyond_materials(self) -> List[Dict[str, Any]]:
+        """获取当前Bioyond物料列表"""
+        try:
+            # 将当前PLR资源转换为Bioyond格式
+            bioyond_materials = []
+            for resource in self.plr_resources.values():
+                unilab_resource = resource_plr_to_ulab(resource)
+                bioyond_materials.extend(resource_ulab_to_bioyond([unilab_resource]))
+            return bioyond_materials
+        except Exception as e:
+            logger.error(f"获取Bioyond物料列表失败: {e}")
+            return []
+    
+    def update_material_from_bioyond(self, material_id: str, bioyond_data: Dict[str, Any]) -> bool:
+        """从Bioyond数据更新指定物料"""
+        try:
+            # 查找现有物料
+            material = self.find_material_by_id(material_id)
+            if not material:
+                logger.warning(f"未找到物料: {material_id}")
+                return False
+            
+            # 转换Bioyond数据为UniLab格式
+            unilab_resources = resource_bioyond_to_ulab([bioyond_data])
+            if not unilab_resources:
+                logger.warning(f"转换Bioyond数据失败: {material_id}")
+                return False
+            
+            # 更新物料属性
+            unilab_resource = unilab_resources[0]
+            material.name = unilab_resource.get("name", material.name)
+            
+            # 更新位置
+            position = unilab_resource.get("position", {})
+            if position:
+                material.location = PLRCoordinate(
+                    position.get("x", 0),
+                    position.get("y", 0),
+                    position.get("z", 0)
+                )
+            
+            logger.info(f"成功更新物料: {material_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新物料失败 {material_id}: {e}")
+            return False
+
+
+class BioyondAPIClient:
+    """Bioyond API客户端（模拟实现）
+    
+    实际使用时需要根据Bioyond系统的API接口实现
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get("base_url", "http://localhost:8080")
+        self.api_key = config.get("api_key", "")
+        self.timeout = config.get("timeout", 30)
+    
+    async def get_materials(self) -> Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]:
+        """从Bioyond系统获取物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            # 暂时返回模拟数据
+            logger.info("从Bioyond API获取物料数据")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据（实际应该从API获取）
+            return {
+                "data": [],
+                "code": 1,
+                "message": "success",
+                "timestamp": 1234567890
+            }
+            
+        except Exception as e:
+            logger.error(f"Bioyond API调用失败: {e}")
+            return None
+    
+    async def update_materials(self, materials: List[Dict[str, Any]]) -> bool:
+        """更新Bioyond系统中的物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"更新Bioyond系统中的 {len(materials)} 个物料")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 模拟成功响应
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新Bioyond物料失败: {e}")
+            return False
+    
+    async def get_material_by_id(self, material_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取单个物料"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"从Bioyond API获取物料: {material_id}")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据
+            return {
+                "id": material_id,
+                "name": f"material_{material_id}",
+                "type": "container",
+                "quantity": 1.0,
+                "unit": "个"
+            }
+            
+        except Exception as e:
+            logger.error(f"获取Bioyond物料失败 {material_id}: {e}")
+            return None

unilabos/devices/workstation/bioyond_cell/bioyond_workstation.py

@@ -0,0 +1,796 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+from datetime import datetime, timezone, timedelta
+import re
+import threading
+
+from urllib3 import response
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now()
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,
+        *args, **kwargs,
+    ):
+        default_config = {
+            #"base_url": "http://192.168.1.200:44388",
+            "base_url": "http://61.169.57.196:44422",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+        self.bioyond_config = {**default_config, **(bioyond_config or {})}
+
+        self.http_service_started = False
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+    #     self.order_status = {}
+    #     try:
+    #         t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+    #         t.start()
+
+    #     except Exception as e:
+    #         logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    # @property
+    # def device_id(self) -> str:
+    #     try:
+    #         return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+    #     except Exception:
+    #         return "bioyond_workstation"
+
+    # def _start_http_service_bg(self, host: str = "192.168.1.104", port: int = 8080) -> None:
+    #     logger.info("进入 _start_http_service_bg 函数")
+    #     try:
+    #         self.service = WorkstationHTTPService(self, host=host, port=port)
+    #         logger.info("WorkstationHTTPService 实例化完成")
+    #         self.service.start()
+    #         self.http_service_started = True
+    #         logger.info(f"unilab_HTTP 服务成功启动: {host}:{port}")
+
+    #         一直挂着，直到进程退出
+    #         while True:
+    #             time.sleep(1)
+
+    #     except Exception as e:
+    #         self.http_service_started = False
+    #         logger.error(f"启动unilab_HTTP服务失败: {e}", exc_info=True)
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+
+        if data is not None:
+            payload["data"] = data
+      
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            #print(r.json())
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+        while True:
+            time.sleep(5)
+            response = self._post_lims("/api/lims/order/orders", orders)
+            if response.get("data", []):
+                break
+            logger.info(f"等待配液实验创建完成")
+
+
+       
+        # self.order_status[response["data"]["orderCode"]] = "running"
+
+        # while True:
+        #     time.sleep(5)
+        #     if self.order_status.get(response["data"]["orderCode"], None) == "finished":
+        #         logger.info(f"配液实验已完成 ，即将执行 3-2-1 转运")
+        #         break
+        #     logger.info(f"等待配液实验完成")
+
+        # self.transfer_3_to_2_to_1()
+        # self.wait_for_transfer_task()
+        # logger.info(f"3-2-1 转运完成，返回结果")
+        # return r321
+        return response
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        response = self._post_lims("/api/lims/scheduler/start")
+        print(response)
+        return response
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+            # 2.9 继续调度
+    def scheduler_continue(self) -> Dict[str, Any]:
+        """
+        继续调度 (2.9)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/continue")
+
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+    # 2.5 批量查询实验报告
+    def order_list_v2(self,
+                      timeType: str = "string",
+                      beginTime: str = "",
+                      endTime: str = "",
+                      status: str = "",
+                      filter: str = "",
+                      skipCount: int = 0,
+                      pageCount: int = 1,
+                      sorting: str = "") -> Dict[str, Any]:
+        """
+        批量查询实验报告的详细信息 (2.5)
+        URL: /api/lims/order/order-list
+        参数默认值和接口文档保持一致
+        """
+        data: Dict[str, Any] = {
+            "timeType": timeType,
+            "beginTime": beginTime,
+            "endTime": endTime,
+            "status": status,
+            "filter": filter,
+            "skipCount": skipCount,
+            "pageCount": pageCount,
+            "sorting": sorting
+        }
+        return self._post_lims("/api/lims/order/order-list", data)
+
+        
+    def wait_for_transfer_task(self, timeout: int = 3000, interval: int = 5, filter_text: Optional[str] = None) -> bool:
+        """
+        轮询查询物料转移任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter=filter_text,
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                # 改成用 filter_text 判断
+                if (not filter_text or filter_text in name) and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}, status={status}")
+                    return True
+
+                logger.info(f"等待中: {name}, status={status}")
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的物料转移任务")
+        return False
+    
+
+    def Bioystation_scheduler_start_task(self) -> bool:
+        logger.info("开始调度")
+        self.scheduler_start()
+        logger.info("调度已启动")
+
+    def Bioystation_scheduler_stop_task(self) -> bool:
+        logger.info("停止调度")
+        self.scheduler_stop()
+        logger.info("调度已停止")
+
+    def Bioystation_scheduler_continue_task(self) -> bool:
+        logger.info("继续调度")
+        self.scheduler_continue()
+        logger.info("调度已继续")
+
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    def Bioystation_feeding4to3_from_xlsx_task(self) -> bool:
+        logger.info("4号箱自动上料开始")
+        r1 = self.auto_feeding4to3_from_xlsx(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板.xlsx")
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("4号箱向3号箱转运物料转移任务已完成")
+        return True
+    
+    # # 新建实验
+    def Bioystation_start_experiment_task(self) -> bool:
+        logger.info("3号箱内实验开始")
+        response = self.create_orders(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\2025101301.xlsx")
+        logger.info(response)
+        data_list = response.get("data", [])
+        order_name = data_list[0].get("orderName", "")
+        self.wait_for_transfer_task(filter_text=order_name)
+        logger.info("3号站内实验完成")
+        return True
+
+    def Bioystation_3_to_2_task(self) -> bool:       
+        self.transfer_3_to_2_to_1()
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("3号站向2号站向1号站转移任务完成")
+        return True
+
+    def Bioystation_1_to_2_task(self) -> bool:
+        self.transfer_1_to_2()
+        self.wait_for_transfer_task(filter_text="物料转移任务")
+        logger.info("1号站向2号站转移任务完成")
+        logger.info("全流程结束")
+        return True
+    
+    def test_benyao_workstation(self, num1, num2):
+        num1 = int(num1)
+        num2 = int(num2)
+        for i in range(num1):
+            print(f"num1 = {num1}")
+        for j in range(num2):
+            print(f"num1 = {num2}")        
+
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    #ws.scheduler_stop()
+    #ws.Bioystation_scheduler_start_task()
+    ws.scheduler_start()
+    # ws.scheduler_start()
+    # logger.info("调度启动完成")
+
+    # ws.scheduler_continue()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    # ws.wait_for_transfer_task(filter_text="物料转移任务")
+    # logger.info("4号箱向3号箱转运物料转移任务已完成")
+
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # # 新建实验
+    # response = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092701.xlsx")
+    # logger.info(response)
+    # data_list = response.get("data", [])
+    # order_name = data_list[0].get("orderName", "")
+
+    # ws.wait_for_transfer_task(filter_text=order_name)
+    # ws.wait_for_transfer_task(filter_text='DP20250927001')
+    # logger.info("3号站内实验完成")
+    # # ws.scheduler_start()
+    # # print(res)
+    # ws.transfer_3_to_2_to_1()
+    # ws.wait_for_transfer_task(filter_text="物料转移任务")
+    # logger.info("3号站向2号站向1号站转移任务完成")
+        # r321 = self.wait_for_transfer_task()
+    #1号站启动
+    # ws.transfer_1_to_2()
+    #s.wait_for_transfer_task(filter_text="物料转移任务")
+    #ogger.info("1号站向2号站转移任务完成")
+    #ogger.info("全流程结束")
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])

unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old (2).py

@@ -0,0 +1,772 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+from datetime import datetime, timezone, timedelta
+import re
+import threading
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,   # 增加调试模式开关
+        *args, **kwargs,
+    ):
+        self.bioyond_config = bioyond_config or {
+            #"base_url": "http://192.168.1.200:44386",
+            #"base_url": "http://172.16.11.219:44388",
+            "base_url": "http://61.169.57.196:44422",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+
+
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+        self.order_status = {}
+        try:
+            t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+            t.start()
+
+        except Exception as e:
+            logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    @property
+    def device_id(self) -> str:
+        try:
+            return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+        except Exception:
+            return "bioyond_workstation"
+
+    def _start_http_service_bg(self, host: str = "192.168.1.104", port: int = 7000) -> None:
+        try:
+            self.service = WorkstationHTTPService(self, host=host, port=port)
+            self.service.start()
+
+        except Exception as e:
+            logger.error(f"启动HTTP服务失败: {e}")
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+        if data is not None:
+            payload["data"] = data
+
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+        print("items", items)
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+
+        response = self._post_lims("/api/lims/order/orders", orders)
+        print(response["data"])
+
+        self.order_status[response["data"][0]["orderCode"]] = "running"
+
+        while True:
+            time.sleep(5)
+            if self.order_status.get(response["data"][0]["orderCode"], None) == "finished":
+                break
+        return response
+
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/scheduler/start")
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+            # 2.9 继续调度
+    def scheduler_continue(self) -> Dict[str, Any]:
+        """
+        继续调度 (2.9)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/continue")
+
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+    # 2.5 批量查询实验报告
+    def order_list_v2(self,
+                      timeType: str = "string",
+                      beginTime: str = "",
+                      endTime: str = "",
+                      status: str = "",
+                      filter: str = "物料转移任务",
+                      skipCount: int = 0,
+                      pageCount: int = 1,
+                      sorting: str = "") -> Dict[str, Any]:
+        """
+        批量查询实验报告的详细信息 (2.5)
+        URL: /api/lims/order/order-list
+        参数默认值和接口文档保持一致
+        """
+        data: Dict[str, Any] = {
+            "timeType": timeType,
+            "beginTime": beginTime,
+            "endTime": endTime,
+            "status": status,
+            "filter": filter,
+            "skipCount": skipCount,
+            "pageCount": pageCount,
+            "sorting": sorting
+        }
+        return self._post_lims("/api/lims/order/order-list", data)
+
+        
+    def wait_for_transfer_task(self, timeout: int = 600, interval: int = 3) -> bool:
+        """
+        轮询查询物料转移任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter="物料转移任务",
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                if name.startswith("物料转移任务") and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}")
+                    return True
+
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的物料转移任务")
+        return False
+    
+    def wait_for_recent_task(self, timeout: int = 600, interval: int = 3) -> bool:
+        """
+        轮询查询最近的任务是否成功完成 (status=80)
+        - timeout: 最大等待秒数 (默认600秒)
+        - interval: 轮询间隔秒数 (默认3秒)
+        返回 True 表示找到并成功完成，False 表示超时未找到
+        """
+        now = datetime.now()
+        beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+        endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        print(beginTime, endTime)
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            result = self.order_list_v2(
+                timeType="string",
+                beginTime=beginTime,
+                endTime=endTime,
+                status="",
+                filter="",
+                skipCount=0,
+                pageCount=1,
+                sorting=""
+            )
+            print(result)
+
+            items = result.get("data", {}).get("items", [])
+            for item in items:
+                name = item.get("name", "")
+                status = item.get("status")
+                if name.startswith("物料转移任务") and status == 80:
+                    logger.info(f"硬件转移动作完成: {name}")
+                    return True
+
+            time.sleep(interval)
+
+        logger.warning("超时未找到成功的任务")
+        return False
+
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    ws.scheduler_stop()
+    ws.scheduler_start()
+    #物料入库
+    r1 = ws.auto_feeding4to3_from_xlsx(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板.xlsx")
+#    print(r1)
+#    print("物料入库任务已提交0")
+#    #等待任务完成
+#    ws.wait_for_transfer_task()
+#
+#    print("物料入库任务已完成1")
+#    
+#    #新建实验
+#    res = ws.create_orders(r"D:\Uni-lab\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\2025092501.xlsx")
+#    print(res)
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+#    print("配液任务已完成")
+#
+#    #新建3-2-1转运任务
+#    r321 = ws.transfer_3_to_2_to_1()
+#    print(r321)
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+#    
+#    ws.transfer_1_to_2()
+#    #等待任务完成
+#    ws.wait_for_recent_task()
+
+
+    #ws._start_http_service_bg()
+    # ws.scheduler_stop()
+    #ws.scheduler_start()
+    # ws.scheduler_continue()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    #ws.wait_for_transfer_task()
+    #print("转运物料转移任务已完成")
+
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # 新建实验
+    # res = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092501.xlsx")
+    # ws.scheduler_start()
+    # print(res)
+    # r321 = ws.transfer_3_to_2_to_1()
+
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])
+    
+    # r321 = ws.transfer_3_to_2_to_1()
+    # ws.transfer_1_to_2()
+
+

unilabos/devices/workstation/bioyond_cell/bioyond_workstation_old.py

@@ -0,0 +1,644 @@
+# -*- coding: utf-8 -*-
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import requests
+from pathlib import Path
+import pandas as pd
+import time
+import threading
+from unilabos.devices.workstation.workstation_base import WorkstationBase
+from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService
+from unilabos.utils.log import logger
+from pylabrobot.resources.deck import Deck
+from .benyao_test import test_benyao_api
+
+def _iso_utc_now_ms() -> str:
+    # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z"
+
+
+class BioyondWorkstation(WorkstationBase):
+    """
+    集成 Bioyond LIMS 的工作站示例，
+    覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) →
+    运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) →
+    查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28)
+    """
+
+    def __init__(
+        self,
+        bioyond_config: Optional[Dict[str, Any]] = None,
+        station_resource: Optional[Dict[str, Any]] = None,
+        debug_mode: bool = False,   # 增加调试模式开关
+        *args, **kwargs,
+    ):
+        self.bioyond_config = bioyond_config or {
+            "base_url": "http://192.168.1.200:44386",
+            "api_key": "8A819E5C",
+            "timeout": 30,
+            "report_token": "CHANGE_ME_TOKEN"
+        }
+
+
+        self.debug_mode = debug_mode
+        super().__init__(deck=Deck, station_resource=station_resource, *args, **kwargs)
+        logger.info(f"Bioyond工作站初始化完成 (debug_mode={self.debug_mode})")
+
+        # 实例化并在后台线程启动 HTTP 报送服务
+        self.order_status = {}
+        try:
+            t = threading.Thread(target=self._start_http_service_bg, daemon=True, name="unilab_http")
+            t.start()
+        except Exception as e:
+            logger.error(f"unilab-server后台启动报送服务失败: {e}")
+
+    @property
+    def device_id(self) -> str:
+        try:
+            return getattr(self, "_ros_node").device_id  # 兼容 ROS 场景
+        except Exception:
+            return "bioyond_workstation"
+
+    def _start_http_service_bg(self, host: str = "127.0.0.1", port: int = 8080) -> None:
+        try:
+            self.service = WorkstationHTTPService(self, host=host, port=port)
+            self.service.start()
+        except Exception as e:
+            logger.error(f"启动HTTP服务失败: {e}")
+
+    # -------------------- 基础HTTP封装 --------------------
+    def _url(self, path: str) -> str:
+        return f"{self.bioyond_config['base_url'].rstrip('/')}/{path.lstrip('/')}"
+
+    def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]:
+        """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装"""
+        payload = {
+            "apiKey": self.bioyond_config["api_key"],
+            "requestTime": _iso_utc_now_ms()
+        }
+        if data is not None:
+            payload["data"] = data
+
+        if self.debug_mode:
+            # 模拟返回，不发真实请求
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+
+        try:
+            r = requests.post(
+                self._url(path),
+                json=payload,
+                timeout=self.bioyond_config.get("timeout", 30),
+                headers={"Content-Type": "application/json"}
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    # --- 修正：_post_report / _post_report_raw 同样走 debug_mode ---
+    def _post_report(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "token": self.bioyond_config.get("report_token", ""),
+            "request_time": _iso_utc_now_ms(),
+            "data": data
+        }
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with payload={payload}")
+            return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=payload,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+    def _post_report_raw(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+        if self.debug_mode:
+            logger.info(f"[DEBUG] POST {path} with body={body}")
+            return {"debug": True, "url": self._url(path), "payload": body, "status": "ok"}
+        try:
+            r = requests.post(self._url(path), json=body,
+                            timeout=self.bioyond_config.get("timeout", 30),
+                            headers={"Content-Type": "application/json"})
+            r.raise_for_status()
+            return r.json()
+        except Exception as e:
+            logger.error(f"POST {path} 失败: {e}")
+            return {"error": str(e)}
+
+
+    # -------------------- 单点接口封装 --------------------
+    # 2.17 入库物料（单个）
+    def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/storage/inbound", {
+            "materialId": material_id,
+            "locationId": location_id
+        })
+
+    # 2.18 批量入库（多个）
+    def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        items = [{"materialId": "...", "locationId": "..."}, ...]
+        """
+        return self._post_lims("/api/lims/storage/batch-inbound", items)
+
+    # 3.30 自动化上料（Excel -> JSON -> POST /api/lims/order/auto-feeding4to3）
+    def auto_feeding4to3_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        根据固定模板解析 Excel：
+        - 四号手套箱加样头面 (2-13行, 3-7列)
+        - 四号手套箱原液瓶面 (15-23行, 3-9列)
+        - 三号手套箱人工堆栈 (26-40行, 3-7列)
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        items: List[Dict[str, Any]] = []
+
+        # 四号手套箱 - 加样头面（2-13行, 3-7列）
+        for _, row in df.iloc[1:13, 2:7].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 四号手套箱 - 原液瓶面（15-23行, 3-9列）
+        for _, row in df.iloc[14:23, 2:9].iterrows():
+            item = {
+                "sourceWHName": "四号手套箱堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialName": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "quantity": float(row[6]) if pd.notna(row[6]) else 0.0,
+                "materialType": str(row[7]).strip() if pd.notna(row[7]) else "",
+                "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "",
+            }
+            if item["materialName"]:
+                items.append(item)
+
+        # 三号手套箱人工堆栈（26-40行, 3-7列）
+        for _, row in df.iloc[25:40, 2:7].iterrows():
+            item = {
+                "sourceWHName": "三号手套箱人工堆栈",
+                "posX": int(row[2]),
+                "posY": int(row[3]),
+                "posZ": int(row[4]),
+                "materialType": str(row[5]).strip() if pd.notna(row[5]) else "",
+                "materialId": str(row[6]).strip() if pd.notna(row[6]) else "",
+                "quantity": 1  # 默认数量1
+            }
+            if item["materialId"] or item["materialType"]:
+                items.append(item)
+
+        return self._post_lims("/api/lims/order/auto-feeding4to3", items)
+
+
+
+    def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        def pick(names: List[str]) -> Optional[str]:
+            for n in names:
+                if n in df.columns:
+                    return n
+            return None
+
+        c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"])
+        c_wh  = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"])
+        c_qty = pick(["数量", "quantity"])
+        c_x   = pick(["x", "X", "posX", "坐标X"])
+        c_y   = pick(["y", "Y", "posY", "坐标Y"])
+        c_z   = pick(["z", "Z", "posZ", "坐标Z"])
+
+        required = [c_loc, c_wh, c_qty, c_x, c_y, c_z]
+        if any(c is None for c in required):
+            raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。")
+
+        def as_int(v, d=0):
+            try:
+                if pd.isna(v): return d
+                return int(v)
+            except Exception:
+                try:
+                    return int(float(v))
+                except Exception:
+                    return d
+
+        def as_float(v, d=0.0):
+            try:
+                if pd.isna(v): return d
+                return float(v)
+            except Exception:
+                return d
+
+        def as_str(v, d=""):
+            if v is None or (isinstance(v, float) and pd.isna(v)): return d
+            s = str(v).strip()
+            return s if s else d
+
+        items: List[Dict[str, Any]] = []
+        for _, row in df.iterrows():
+            items.append({
+                "locationId": as_str(row[c_loc]),
+                "warehouseId": as_str(row[c_wh]),
+                "quantity": as_float(row[c_qty]),
+                "x": as_int(row[c_x]),
+                "y": as_int(row[c_y]),
+                "z": as_int(row[c_z]),
+            })
+
+        return self._post_lims("/api/lims/storage/auto-batch-out-bound", items)
+
+    # 2.14 新建实验
+    def create_orders(self, xlsx_path: str) -> Dict[str, Any]:
+        """
+        从 Excel 解析并创建实验（2.14）
+        约定：
+        - batchId = Excel 文件名（不含扩展名）
+        - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列）
+        - totalMass 自动计算为所有物料质量之和
+        - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D）
+        """
+        path = Path(xlsx_path)
+        if not path.exists():
+            raise FileNotFoundError(f"未找到 Excel 文件：{path}")
+
+        try:
+            df = pd.read_excel(path, sheet_name=0, engine="openpyxl")
+        except Exception as e:
+            raise RuntimeError(f"读取 Excel 失败：{e}")
+
+        # 列名容错：返回可选列名，找不到则返回 None
+        def _pick(col_names: List[str]) -> Optional[str]:
+            for c in col_names:
+                if c in df.columns:
+                    return c
+            return None
+
+        col_order_name = _pick(["配方ID", "orderName", "订单编号"])
+        col_create_time = _pick(["创建日期", "createTime"])
+        col_bottle_type = _pick(["配液瓶类型", "bottleType"])
+        col_mix_time = _pick(["混匀时间(s)", "mixTime"])
+        col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"])
+        col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"])
+        col_cond = _pick(["电导测试分液体积", "conductivityInfo"])
+        col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"])
+
+        # 物料列：所有以 (g) 结尾
+        material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")]
+        if not material_cols:
+            raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。")
+
+        batch_id = path.stem
+
+        def _to_ymd_slash(v) -> str:
+            # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期
+            if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "":
+                ts = datetime.now()
+            else:
+                try:
+                    ts = pd.to_datetime(v)
+                except Exception:
+                    ts = datetime.now()
+            return f"{ts.year}/{ts.month}/{ts.day}"
+
+        def _as_int(val, default=0) -> int:
+            try:
+                if pd.isna(val):
+                    return default
+                return int(val)
+            except Exception:
+                return default
+
+        def _as_str(val, default="") -> str:
+            if val is None or (isinstance(val, float) and pd.isna(val)):
+                return default
+            s = str(val).strip()
+            return s if s else default
+
+        orders: List[Dict[str, Any]] = []
+
+        for idx, row in df.iterrows():
+            mats: List[Dict[str, Any]] = []
+            total_mass = 0.0
+
+            for mcol in material_cols:
+                val = row.get(mcol, None)
+                if val is None or (isinstance(val, float) and pd.isna(val)):
+                    continue
+                try:
+                    mass = float(val)
+                except Exception:
+                    continue
+                if mass > 0:
+                    mats.append({"name": mcol.replace("(g)", ""), "mass": mass})
+                    total_mass += mass
+
+            order_data = {
+                "batchId": batch_id,
+                "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}",
+                "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None),
+                "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶",
+                "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0,
+                "loadSheddingInfo": _as_int(row[col_load]) if col_load else 0,
+                "pouchCellInfo": _as_int(row[col_pouch]) if col_pouch else 0,
+                "conductivityInfo": _as_int(row[col_cond]) if col_cond else 0,
+                "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0,
+                "materialInfos": mats,
+                "totalMass": round(total_mass, 4)  # 自动汇总
+            }
+            orders.append(order_data)
+
+        # print(orders)
+
+        response = self._post_lims("/api/lims/order/orders", orders)
+        self.order_status[response["data"]["orderCode"]] = "running"
+
+        while True:
+            time.sleep(5)
+            if self.order_status.get(response["data"]["orderCode"], None) == "finished":
+                break
+        return response
+
+
+    # 2.7 启动调度
+    def scheduler_start(self) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/scheduler/start")
+    # 3.10 停止调度
+    def scheduler_stop(self) -> Dict[str, Any]:
+        """
+        停止调度 (3.10)
+        请求体只包含 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/scheduler/stop")
+
+
+    # 2.24 物料变更推送
+    def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等）
+        """
+        return self._post_report_raw("/report/material_change", material_obj)
+
+    # 2.21 步骤完成推送（BS → LIMS）
+    def report_step_finish(self,
+                           order_code: str,
+                           order_name: str,
+                           step_name: str,
+                           step_id: str,
+                           sample_id: str,
+                           start_time: str,
+                           end_time: str,
+                           execution_status: str = "completed") -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "stepName": step_name,
+            "stepId": step_id,
+            "sampleId": sample_id,
+            "startTime": start_time,
+            "endTime": end_time,
+            "executionStatus": execution_status
+        }
+        return self._post_report("/report/step_finish", data)
+
+    # 2.23 订单完成推送（BS → LIMS）
+    def report_order_finish(self,
+                            order_code: str,
+                            order_name: str,
+                            start_time: str,
+                            end_time: str,
+                            status: str = "30",  # 30 完成 / -11 异常停止 / -12 人工停止
+                            workflow_status: str = "Finished",
+                            completion_time: Optional[str] = None,
+                            used_materials: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        data = {
+            "orderCode": order_code,
+            "orderName": order_name,
+            "startTime": start_time,
+            "endTime": end_time,
+            "status": status,
+            "workflowStatus": workflow_status,
+            "completionTime": completion_time or end_time,
+            "usedMaterials": used_materials or []
+        }
+        return self._post_report("/report/order_finish", data)
+
+    # 2.5 批量查询实验报告（用于轮询是否完成）
+    def order_list(self,
+                   status: Optional[str] = None,
+                   begin_time: Optional[str] = None,
+                   end_time: Optional[str] = None,
+                   filter_text: Optional[str] = None,
+                   skip: int = 0, page: int = 10) -> Dict[str, Any]:
+        data: Dict[str, Any] = {"skipCount": skip, "pageCount": page}
+        if status is not None:  # 80 成功 / 90 失败 / 100 执行中
+            data["status"] = status
+        if begin_time:
+            data["timeType"] = "CreationTime"
+            data["beginTime"] = begin_time
+        if end_time:
+            data["endTime"] = end_time
+        if filter_text:
+            data["filter"] = filter_text
+        return self._post_lims("/api/lims/order/order-list", data)
+
+    # 2.6 实验报告查询（根据任务ID拿详情）
+    def order_report(self, order_id: str) -> Dict[str, Any]:
+        return self._post_lims("/api/lims/order/order-report", order_id)
+
+    # 2.32 3-2-1 物料转运
+    def transfer_3_to_2_to_1(self,
+                            #  source_wh_id: Optional[str] = None,
+                            source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b',
+                             source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z
+        }
+        if source_wh_id:
+            payload["sourceWHID"] = source_wh_id
+        return self._post_lims("/api/lims/order/transfer-task3To2To1", payload)
+
+    # 2.28 样品/废料取出
+    def take_out(self,
+                 order_id: str,
+                 preintake_ids: Optional[List[str]] = None,
+                 material_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        data = {
+            "orderId": order_id,
+            "preintakeIds": preintake_ids or [],
+            "materialIds": material_ids or []
+        }
+        return self._post_lims("/api/lims/order/take-out", data)
+
+    # --------（可选）占位方法：文档未定义的“1号站内部流程 / 1-2转运”--------
+    def start_station1_internal_flow(self, **kwargs) -> None:
+        logger.info("启动1号站内部流程（占位，按现场系统填充具体指令）")
+
+
+    # 3.x 1→2 物料转运
+    def transfer_1_to_2(self) -> Dict[str, Any]:
+        """
+        1→2 物料转运
+        URL: /api/lims/order/transfer-task1To2
+        只需要 apiKey 和 requestTime
+        """
+        return self._post_lims("/api/lims/order/transfer-task1To2")
+
+
+    # -------------------- 整体编排 --------------------
+    def run_full_workflow(self,
+                          inbound_items: List[Dict[str, str]],
+                          orders: List[Dict[str, Any]],
+                          poll_filter_code: Optional[str] = None,
+                          poll_timeout_s: int = 600,
+                          poll_interval_s: int = 5,
+                          transfer_source: Optional[Dict[str, Any]] = None,
+                          takeout_order_id: Optional[str] = None) -> None:
+        """
+        一键串联：
+        1) 入库 3-4 个物料 → 2) 新建实验 → 3) 启动调度
+        运行中（如需）：4) 物料变更推送 5) 步骤完成推送 6) 订单完成推送
+        完成后：查询实验（2.5/2.6）→ 7) 3-2-1 转运 → 8) 1号站内部流程
+        → 9) 1-2 转运 → 10) 样品/废料取出
+        """
+        # 1. 入库（多于1个就用批量接口 2.18）
+        if len(inbound_items) == 1:
+            r = self.storage_inbound(inbound_items[0]["materialId"], inbound_items[0]["locationId"])
+            logger.info(f"单个入库结果: {r}")
+        else:
+            r = self.storage_batch_inbound(inbound_items)
+            logger.info(f"批量入库结果: {r}")
+
+        # 2. 新建实验（2.14）
+        r = self.create_orders(orders)
+        logger.info(f"新建实验结果: {r}")
+
+        # 3. 启动调度（2.7）
+        r = self.scheduler_start()
+        logger.info(f"启动调度结果: {r}")
+
+        # —— 运行中各类推送（2.24 / 2.21 / 2.23），通常由实际任务驱动，这里提供调用方式 —— #
+        # self.report_material_change({...})
+        # self.report_step_finish(order_code="BSO...", order_name="配液分液", step_name="xxx", step_id="...", sample_id="...",
+        #                         start_time=_iso_utc_now_ms(), end_time=_iso_utc_now_ms(), execution_status="completed")
+        # self.report_order_finish(order_code="BSO...", order_name="配液分液", start_time="...", end_time=_iso_utc_now_ms())
+
+        # 完成后才能转运：用 2.5 批量查询配合 filter=任务编码 轮询到 status=80（成功）
+        if poll_filter_code:
+            import time
+            deadline = time.time() + poll_timeout_s
+            while time.time() < deadline:
+                res = self.order_list(status="80", filter_text=poll_filter_code, page=5)
+                if isinstance(res, dict) and res.get("data", {}).get("items"):
+                    logger.info(f"实验 {poll_filter_code} 已完成：{res['data']['items'][0]}")
+                    break
+                time.sleep(poll_interval_s)
+            else:
+                logger.warning(f"等待实验 {poll_filter_code} 完成超时（未到 status=80）")
+
+        # 7. 启动 3-2-1 转运（2.32）
+        if transfer_source:
+            r = self.transfer_3_to_2_to_1(
+                source_wh_id=transfer_source.get("sourceWHID"),
+                source_x=transfer_source.get("sourcePosX", 1),
+                source_y=transfer_source.get("sourcePosY", 1),
+                source_z=transfer_source.get("sourcePosZ", 1),
+            )
+            logger.info(f"3-2-1 转运结果: {r}")
+
+        # 8. 1号站内部流程（占位）
+        self.start_station1_internal_flow()
+
+        # 9. 1→2 转运（占位）
+        self.transfer_1_to_2()
+
+        # 10. 样品/废料取出（2.28）
+        if takeout_order_id:
+            r = self.take_out(order_id=takeout_order_id)
+            logger.info(f"样品/废料取出结果: {r}")
+
+
+    # 套接字服务端收到“步骤完成”时调用
+    def process_step_finish_report(self, report_request):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "step_finished"
+            logger.info(f"[REPORT] 订单 {order_code} 步骤完成")
+        return {"ack": True}
+
+    def process_order_finish_report(self, report_request, used_materials=None):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "finished"
+            logger.info(f"[REPORT] 订单 {order_code} 已完成，状态改为 finished")
+        return {"ack": True, "usedMaterials": used_materials or []}
+
+    # 收到“通量完成”时调用
+    def process_sample_finish_report(self, report_request):
+        order_code = report_request.data.get("orderCode")
+        if order_code:
+            self.order_status[order_code] = "sample_finished"
+            logger.info(f"[REPORT] 订单 {order_code} 通量完成")
+        return {"ack": True}
+
+    def test_benyao_workstation(self, num1, num2):
+        num1 = int(num1)
+        num2 = int(num2)
+        for i in range(num1):
+            print(f"num1 = {num1}")
+        for j in range(num2):
+            print(f"num1 = {num2}")
+        test_benyao_api()
+        
+        
+# --------------------------------
+if __name__ == "__main__":
+    ws = BioyondWorkstation()
+    # ws.scheduler_stop()
+    # 3.30 上料：读取模板 Excel 自动解析并 POST
+    # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板 (8).xlsx")
+    # ws.scheduler_start()
+    # print(r1["payload"]["data"])   # 调试模式下可直接看到要发的 JSON items
+
+    # 新建实验
+    # res = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092501.xlsx")
+    # print(res)
+
+    # 3.31 下料：同理
+    # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx")
+    # print(r2["payload"]["data"])
+    
+    # r321 = ws.transfer_3_to_2_to_1()
+    # ws.transfer_1_to_2()
+
+

unilabos/devices/workstation/bioyond_cell/cellconfig3c.json

@@ -0,0 +1,706 @@
+{
+  "nodes": [
+  {
+        "id": "bioyond_workstation",
+        "name": "配液分液工站",
+        "children": [
+        ],
+        "parent": null,
+        "type": "device",
+        "class": "bioyondworkstation_device",
+        "config": {
+            "protocol_type": [],
+            "station_resource": {}
+
+        },
+        "data": {}
+    },
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "children": [
+          "coin_cell_deck"
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "bettery_station_registry",
+      "position": {
+          "x": 600,
+          "y": 400,
+          "z": 0
+      },
+      "config": {
+          "debug_mode": false,
+          "_comment": "protocol_type接外部工站固定写法字段，一般为空，station_resource写法也固定",
+          "protocol_type": [],
+          "station_resource": {
+              "data": {
+                  "_resource_child_name": "coin_cell_deck",
+                  "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.button_battery_station:CoincellDeck"
+              }
+          },
+          
+          "address": "192.168.1.20",
+          "port": 502
+      },
+      "data": {}
+    },
+    {
+      "id": "coin_cell_deck",
+      "name": "coin_cell_deck",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8"
+      ],
+      "parent": null,
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "CoincellDeck",
+        "size_x": 1000,
+        "size_y": 1000,
+        "size_z": 900,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "coin_cell_deck",
+        "barcode": null
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8",
+      "name": "\u7535\u6c60\u6599\u76d8",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+      ],
+      "parent": "coin_cell_deck",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 100,
+        "y": 100,
+        "z": 0
+      },
+      "config": {
+        "type": "MaterialPlate",
+        "size_x": 120.8,
+        "size_y": 160.5,
+        "size_z": 10.0,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {
+          "A1": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+          "B1": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+          "C1": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+          "D1": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+          "A2": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+          "B2": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+          "C2": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+          "D2": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+          "A3": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+          "B3": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+          "C3": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+          "D3": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+          "A4": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+          "B4": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+          "C4": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+          "D4": "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+        }
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    }
+  ],
+  "links": []
+}

unilabos/devices/workstation/bioyond_cell/cellconfig3ca.json

@@ -0,0 +1,20 @@
+{
+  "nodes": [
+  {
+        "id": "bioyond_workstation",
+        "name": "配液分液工站",
+        "children": [
+        ],
+        "parent": null,
+        "type": "device",
+        "class": "bioyondworkstation_device",
+        "config": {
+            "protocol_type": [],
+            "station_resource": {}
+
+        },
+        "data": {}
+    }
+  ],
+  "links": []
+}

unilabos/devices/workstation/bioyond_material_management.py

@@ -0,0 +1,374 @@
+"""
+Bioyond物料管理实现
+Bioyond Material Management Implementation
+
+基于Bioyond系统的物料管理，支持从Bioyond系统同步物料到UniLab工作站
+"""
+from typing import Dict, Any, List, Optional, Union
+import json
+import asyncio
+from abc import ABC, abstractmethod
+
+from pylabrobot.resources import (
+    Resource as PLRResource,
+    Container,
+    Deck,
+    Coordinate as PLRCoordinate,
+)
+
+from unilabos.ros.nodes.resource_tracker import DeviceNodeResourceTracker
+from unilabos.utils.log import logger
+from unilabos.resources.graphio import (
+    resource_plr_to_ulab, 
+    resource_ulab_to_plr,
+    resource_bioyond_to_ulab,
+    resource_bioyond_container_to_ulab,
+    resource_ulab_to_bioyond
+)
+from .workstation_material_management import MaterialManagementBase
+
+
+class BioyondMaterialManagement(MaterialManagementBase):
+    """Bioyond物料管理类
+    
+    实现从Bioyond系统同步物料到UniLab工作站的功能：
+    1. 从Bioyond系统获取物料数据
+    2. 转换为UniLab格式
+    3. 同步到PyLabRobot Deck
+    4. 支持双向同步
+    """
+    
+    def __init__(
+        self,
+        device_id: str,
+        deck_config: Dict[str, Any],
+        resource_tracker: DeviceNodeResourceTracker,
+        children_config: Dict[str, Dict[str, Any]] = None,
+        bioyond_config: Dict[str, Any] = None
+    ):
+        self.bioyond_config = bioyond_config or {}
+        self.bioyond_api_client = None
+        self.sync_interval = self.bioyond_config.get("sync_interval", 30)  # 同步间隔（秒）
+        
+        # 初始化父类
+        super().__init__(device_id, deck_config, resource_tracker, children_config)
+        
+        # 初始化Bioyond API客户端
+        self._initialize_bioyond_client()
+        
+        # 启动同步任务
+        self._start_sync_task()
+    
+    def _initialize_bioyond_client(self):
+        """初始化Bioyond API客户端"""
+        try:
+            # 这里应该根据实际的Bioyond API实现
+            # 暂时使用模拟客户端
+            self.bioyond_api_client = BioyondAPIClient(self.bioyond_config)
+            logger.info(f"Bioyond API客户端初始化成功")
+        except Exception as e:
+            logger.error(f"Bioyond API客户端初始化失败: {e}")
+            self.bioyond_api_client = None
+    
+    def _start_sync_task(self):
+        """启动同步任务"""
+        if self.bioyond_api_client:
+            # 创建异步同步任务
+            asyncio.create_task(self._periodic_sync())
+            logger.info(f"Bioyond同步任务已启动，间隔: {self.sync_interval}秒")
+    
+    async def _periodic_sync(self):
+        """定期同步任务"""
+        while True:
+            try:
+                await self.sync_from_bioyond()
+                await asyncio.sleep(self.sync_interval)
+            except Exception as e:
+                logger.error(f"Bioyond同步任务出错: {e}")
+                await asyncio.sleep(self.sync_interval)
+    
+    async def sync_from_bioyond(self) -> bool:
+        """从Bioyond系统同步物料"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 从Bioyond获取物料数据
+            bioyond_data = await self.bioyond_api_client.get_materials()
+            if not bioyond_data:
+                logger.warning("从Bioyond获取物料数据为空")
+                return False
+            
+            # 2. 转换为UniLab格式
+            if isinstance(bioyond_data, dict) and "data" in bioyond_data:
+                # 容器格式数据
+                unilab_resources = resource_bioyond_container_to_ulab(bioyond_data)
+            else:
+                # 物料列表格式数据
+                unilab_resources = resource_bioyond_to_ulab(bioyond_data)
+            
+            # 3. 转换为PLR格式并分配到Deck
+            await self._assign_resources_to_deck(unilab_resources)
+            
+            logger.info(f"从Bioyond同步了 {len(unilab_resources)} 个资源")
+            return True
+            
+        except Exception as e:
+            logger.error(f"从Bioyond同步物料失败: {e}")
+            return False
+    
+    async def sync_to_bioyond(self, plr_resource: PLRResource) -> bool:
+        """将本地物料变更同步到Bioyond系统"""
+        try:
+            if not self.bioyond_api_client:
+                logger.warning("Bioyond API客户端未初始化")
+                return False
+            
+            # 1. 转换为UniLab格式
+            unilab_resource = resource_plr_to_ulab(plr_resource)
+            
+            # 2. 转换为Bioyond格式
+            bioyond_materials = resource_ulab_to_bioyond([unilab_resource])
+            
+            # 3. 发送到Bioyond系统
+            success = await self.bioyond_api_client.update_materials(bioyond_materials)
+            
+            if success:
+                logger.info(f"成功同步物料 {plr_resource.name} 到Bioyond")
+            else:
+                logger.warning(f"同步物料 {plr_resource.name} 到Bioyond失败")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"同步物料到Bioyond失败: {e}")
+            return False
+    
+    async def _assign_resources_to_deck(self, unilab_resources: List[Dict[str, Any]]):
+        """将UniLab资源分配到Deck"""
+        try:
+            # 转换为PLR格式
+            from unilabos.resources.graphio import list_to_nested_dict
+            nested_resources = list_to_nested_dict(unilab_resources)
+            plr_resources = resource_ulab_to_plr(nested_resources)
+            
+            # 分配资源到Deck
+            if hasattr(plr_resources, 'children'):
+                resources_to_assign = plr_resources.children
+            elif isinstance(plr_resources, list):
+                resources_to_assign = plr_resources
+            else:
+                resources_to_assign = [plr_resources]
+            
+            for resource in resources_to_assign:
+                try:
+                    # 获取资源位置
+                    if hasattr(resource, 'location') and resource.location:
+                        location = PLRCoordinate(resource.location.x, resource.location.y, resource.location.z)
+                    else:
+                        location = PLRCoordinate(0, 0, 0)
+                    
+                    # 分配资源到Deck
+                    self.plr_deck.assign_child_resource(resource, location)
+                    
+                    # 注册到resource tracker
+                    self.resource_tracker.add_resource(resource)
+                    
+                    # 保存资源引用
+                    self.plr_resources[resource.name] = resource
+                    
+                except Exception as e:
+                    logger.error(f"分配资源 {resource.name} 到Deck失败: {e}")
+            
+            logger.info(f"成功分配了 {len(resources_to_assign)} 个资源到Deck")
+            
+        except Exception as e:
+            logger.error(f"分配资源到Deck失败: {e}")
+    
+    def _create_resource_by_type(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """根据类型创建Bioyond相关资源"""
+        try:
+            # 这里可以根据需要实现特定的Bioyond资源类型
+            # 目前使用通用的容器类型
+            if resource_type in ["container", "plate", "well"]:
+                return self._create_generic_container(resource_id, resource_type, config, data, location)
+            else:
+                logger.warning(f"未知的Bioyond资源类型: {resource_type}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"创建Bioyond资源失败 {resource_id} ({resource_type}): {e}")
+            return None
+    
+    def _create_generic_container(
+        self, 
+        resource_id: str, 
+        resource_type: str, 
+        config: Dict[str, Any], 
+        data: Dict[str, Any], 
+        location: PLRCoordinate
+    ) -> Optional[PLRResource]:
+        """创建通用容器资源"""
+        try:
+            from pylabrobot.resources import Plate, Well
+            
+            if resource_type == "plate":
+                return Plate(
+                    name=resource_id,
+                    size_x=config.get("size_x", 127.76),
+                    size_y=config.get("size_y", 85.48),
+                    size_z=config.get("size_z", 14.35),
+                    location=location,
+                    category="plate"
+                )
+            elif resource_type == "well":
+                return Well(
+                    name=resource_id,
+                    size_x=config.get("size_x", 9.0),
+                    size_y=config.get("size_y", 9.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="well"
+                )
+            else:
+                return Container(
+                    name=resource_id,
+                    size_x=config.get("size_x", 50.0),
+                    size_y=config.get("size_y", 50.0),
+                    size_z=config.get("size_z", 10.0),
+                    location=location,
+                    category="container"
+                )
+                
+        except Exception as e:
+            logger.error(f"创建通用容器失败 {resource_id}: {e}")
+            return None
+    
+    def get_bioyond_materials(self) -> List[Dict[str, Any]]:
+        """获取当前Bioyond物料列表"""
+        try:
+            # 将当前PLR资源转换为Bioyond格式
+            bioyond_materials = []
+            for resource in self.plr_resources.values():
+                unilab_resource = resource_plr_to_ulab(resource)
+                bioyond_materials.extend(resource_ulab_to_bioyond([unilab_resource]))
+            return bioyond_materials
+        except Exception as e:
+            logger.error(f"获取Bioyond物料列表失败: {e}")
+            return []
+    
+    def update_material_from_bioyond(self, material_id: str, bioyond_data: Dict[str, Any]) -> bool:
+        """从Bioyond数据更新指定物料"""
+        try:
+            # 查找现有物料
+            material = self.find_material_by_id(material_id)
+            if not material:
+                logger.warning(f"未找到物料: {material_id}")
+                return False
+            
+            # 转换Bioyond数据为UniLab格式
+            unilab_resources = resource_bioyond_to_ulab([bioyond_data])
+            if not unilab_resources:
+                logger.warning(f"转换Bioyond数据失败: {material_id}")
+                return False
+            
+            # 更新物料属性
+            unilab_resource = unilab_resources[0]
+            material.name = unilab_resource.get("name", material.name)
+            
+            # 更新位置
+            position = unilab_resource.get("position", {})
+            if position:
+                material.location = PLRCoordinate(
+                    position.get("x", 0),
+                    position.get("y", 0),
+                    position.get("z", 0)
+                )
+            
+            logger.info(f"成功更新物料: {material_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新物料失败 {material_id}: {e}")
+            return False
+
+
+class BioyondAPIClient:
+    """Bioyond API客户端（模拟实现）
+    
+    实际使用时需要根据Bioyond系统的API接口实现
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get("base_url", "http://localhost:8080")
+        self.api_key = config.get("api_key", "")
+        self.timeout = config.get("timeout", 30)
+    
+    async def get_materials(self) -> Optional[Union[Dict[str, Any], List[Dict[str, Any]]]]:
+        """从Bioyond系统获取物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            # 暂时返回模拟数据
+            logger.info("从Bioyond API获取物料数据")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据（实际应该从API获取）
+            return {
+                "data": [],
+                "code": 1,
+                "message": "success",
+                "timestamp": 1234567890
+            }
+            
+        except Exception as e:
+            logger.error(f"Bioyond API调用失败: {e}")
+            return None
+    
+    async def update_materials(self, materials: List[Dict[str, Any]]) -> bool:
+        """更新Bioyond系统中的物料数据"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"更新Bioyond系统中的 {len(materials)} 个物料")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 模拟成功响应
+            return True
+            
+        except Exception as e:
+            logger.error(f"更新Bioyond物料失败: {e}")
+            return False
+    
+    async def get_material_by_id(self, material_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取单个物料"""
+        try:
+            # 这里应该实现实际的API调用
+            logger.info(f"从Bioyond API获取物料: {material_id}")
+            
+            # 模拟API调用延迟
+            await asyncio.sleep(0.1)
+            
+            # 返回模拟数据
+            return {
+                "id": material_id,
+                "name": f"material_{material_id}",
+                "type": "container",
+                "quantity": 1.0,
+                "unit": "个"
+            }
+            
+        except Exception as e:
+            logger.error(f"获取Bioyond物料失败 {material_id}: {e}")
+            return None

unilabos/devices/workstation/bioyond_studio/experiment.py

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

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_0910.csv

@@ -0,0 +1,44 @@
+Name,DataType,InitValue,Comment,Attribute,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_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,UNILAB<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䷽<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,coil,8700
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,UNILAB<EFBFBD><EFBFBD><EFBFBD>ܲ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,coil,8710
+COIL_SYS_START_STATUS,BOOL,,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,coil,8210
+COIL_SYS_STOP_STATUS,BOOL,,<EFBFBD>豸ֹͣ<EFBFBD><EFBFBD>,,coil,8220
+COIL_SYS_RESET_STATUS,BOOL,,<EFBFBD>豸<EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD>,,coil,8230
+COIL_SYS_HAND_STATUS,BOOL,,<EFBFBD>豸<EFBFBD>ֶ<EFBFBD>ģʽ,,coil,8240
+COIL_SYS_AUTO_STATUS,BOOL,,<EFBFBD>豸<EFBFBD>Զ<EFBFBD>ģʽ,,coil,8250
+COIL_SYS_INIT_STATUS,BOOL,,<EFBFBD>豸<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,coil,8260
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>䷽,,coil,8510
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,<EFBFBD>豸<EFBFBD><EFBFBD><EFBFBD><EFBFBD><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_NUM,INT16,,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һʹ<EFBFBD><EFBFBD>ƿ<EFBFBD><EFBFBD>,,hold_register,11002
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>ȡ<EFBFBD><EFBFBD>,,hold_register,11004
+REG_MSG_ASSEMBLY_TYPE,INT16,,<EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD>ѵ<EFBFBD><EFBFBD><EFBFBD>ʽ,,hold_register,11006
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,hold_register,11008
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,hold_register,10000
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>ѹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,hold_register,10002
+REG_DATA_AXIS_X_POS,FLOAT32,,<EFBFBD><EFBFBD>ҺX<EFBFBD>ᵱǰλ<EFBFBD><EFBFBD>,,hold_register,10004
+REG_DATA_AXIS_Y_POS,FLOAT32,,<EFBFBD><EFBFBD>ҺZ<EFBFBD>ᵱǰλ<EFBFBD><EFBFBD>,,hold_register,10006
+REG_DATA_AXIS_Z_POS,FLOAT32,,<EFBFBD><EFBFBD>ҺY<EFBFBD>ᵱǰλ<EFBFBD><EFBFBD>,,hold_register,10008
+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_COIN_NUM,INT16,,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,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,12004
+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
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,Unilabȷ<EFBFBD><EFBFBD><EFBFBD>ѷ<EFBFBD><EFBFBD>͵<EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD><EFBFBD>ź<EFBFBD>,,coil,8720
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,Unilab<EFBFBD>ɽ<EFBFBD><EFBFBD>ܵ<EFBFBD><EFBFBD><EFBFBD>Һƿ<EFBFBD><EFBFBD>,,coil,8520
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Һ<EFBFBD><EFBFBD>װ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,hold_register,496
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>װƽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,hold_register,10000
+UNILAB_SEND_FINISHED_CMD,BOOL,,Unilab<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ź<EFBFBD>,,coil,8730
+UNILAB_RECE_FINISHED_CMD,BOOL,,<EFBFBD><EFBFBD>֪unilab<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ź<EFBFBD>,,coil,8530

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_a.csv

@@ -0,0 +1,46 @@
+Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
+COIL_SYS_START_CMD,BOOL,,,,coil,8010,
+COIL_SYS_STOP_CMD,BOOL,,,,coil,8020,
+COIL_SYS_RESET_CMD,BOOL,,,,coil,8030,
+COIL_SYS_HAND_CMD,BOOL,,,,coil,8040,
+COIL_SYS_AUTO_CMD,BOOL,,,,coil,8050,
+COIL_SYS_INIT_CMD,BOOL,,,,coil,8060,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,8700,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,8710,unilab_rec_msg_succ_cmd
+COIL_SYS_START_STATUS,BOOL,,,,coil,8210,
+COIL_SYS_STOP_STATUS,BOOL,,,,coil,8220,
+COIL_SYS_RESET_STATUS,BOOL,,,,coil,8230,
+COIL_SYS_HAND_STATUS,BOOL,,,,coil,8240,
+COIL_SYS_AUTO_STATUS,BOOL,,,,coil,8250,
+COIL_SYS_INIT_STATUS,BOOL,,,,coil,8260,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,8500,
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,8510,request_send_msg_status
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,11000,
+REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,11002,unilab_send_msg_electrolyte_num
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,11004,unilab_send_msg_electrolyte_vol
+REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,11006,unilab_send_msg_assembly_type
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,11008,unilab_send_msg_assembly_pressure
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,10000,data_assembly_coin_cell_num
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,10002,data_open_circuit_voltage
+REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,10004,
+REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,10006,
+REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,10008,
+REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,10010,data_pole_weight
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,10012,data_assembly_time
+REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,10014,data_assembly_pressure
+REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,10016,data_electrolyte_volume
+REG_DATA_COIN_NUM,INT16,,,,hold_register,10018,data_coin_num
+REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,10020,data_electrolyte_code()
+REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,10030,data_coin_cell_code()
+REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,12004,data_stack_vision_code()
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,10050,data_glove_box_pressure
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,10052,data_glove_box_water_content
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,10054,data_glove_box_o2_content
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8720,
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8520,
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,496,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,10000,
+UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,8730,
+UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,8530,
+REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,10018,ASSEMBLY_TYPE7or8
+COIL_ALUMINUM_FOIL,BOOL,,,,coil,8340,

unilabos/devices/workstation/coin_cell_assembly/new_cellconfig3c.json

@@ -0,0 +1,691 @@
+{
+  "nodes": [
+    {
+      "id": "BatteryStation",
+      "name": "扣电工作站",
+      "children": [
+          "coin_cell_deck"
+      ],
+      "parent": null,
+      "type": "device",
+      "class": "bettery_station_registry",
+      "position": {
+          "x": 600,
+          "y": 400,
+          "z": 0
+      },
+      "config": {
+          "debug_mode": false,
+          "_comment": "protocol_type接外部工站固定写法字段，一般为空，station_resource写法也固定",
+          "protocol_type": [],
+          "station_resource": {
+              "data": {
+                  "_resource_child_name": "coin_cell_deck",
+                  "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.button_battery_station:CoincellDeck"
+              }
+          },
+          
+          "address": "192.168.1.20",
+          "port": 502
+      },
+      "data": {}
+    },
+    {
+      "id": "coin_cell_deck",
+      "name": "coin_cell_deck",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8"
+      ],
+      "parent": null,
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+      },
+      "config": {
+        "type": "CoincellDeck",
+        "size_x": 1000,
+        "size_y": 1000,
+        "size_z": 900,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "coin_cell_deck",
+        "barcode": null
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8",
+      "name": "\u7535\u6c60\u6599\u76d8",
+      "sample_id": null,
+      "children": [
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+        "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+      ],
+      "parent": "coin_cell_deck",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 100,
+        "y": 100,
+        "z": 0
+      },
+      "config": {
+        "type": "MaterialPlate",
+        "size_x": 120.8,
+        "size_y": 160.5,
+        "size_z": 10.0,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_plate",
+        "model": null,
+        "barcode": null,
+        "ordering": {
+          "A1": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+          "B1": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+          "C1": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+          "D1": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+          "A2": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+          "B2": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+          "C2": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+          "D2": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+          "A3": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+          "B3": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+          "C3": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+          "D3": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+          "A4": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+          "B4": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+          "C4": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+          "D4": "\u7535\u6c60\u6599\u76d8_materialhole_3_3"
+        }
+      },
+      "data": {}
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_0_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 12.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_1_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 36.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_2_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 60.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_0",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 104.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_1",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 80.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_2",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 56.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    },
+    {
+      "id": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "name": "\u7535\u6c60\u6599\u76d8_materialhole_3_3",
+      "sample_id": null,
+      "children": [],
+      "parent": "\u7535\u6c60\u6599\u76d8",
+      "type": "container",
+      "class": "",
+      "position": {
+        "x": 84.4,
+        "y": 32.25,
+        "z": 10.0
+      },
+      "config": {
+        "type": "MaterialHole",
+        "size_x": 16,
+        "size_y": 16,
+        "size_z": 16,
+        "rotation": {
+          "x": 0,
+          "y": 0,
+          "z": 0,
+          "type": "Rotation"
+        },
+        "category": "material_hole",
+        "model": null,
+        "barcode": null
+      },
+      "data": {
+        "diameter": 20,
+        "depth": 10,
+        "max_sheets": 1,
+        "info": null
+      }
+    }
+  ],
+  "links": []
+}

unilabos/devices/workstation/workflow_executors.py

@@ -0,0 +1,649 @@
+"""
+工作流执行器模块
+Workflow Executors Module
+
+基于单一硬件接口的工作流执行器实现
+支持Modbus、HTTP、PyLabRobot和代理模式
+"""
+import time
+import json
+import asyncio
+from typing import Dict, Any, List, Optional, TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from unilabos.devices.work_station.workstation_base import WorkstationBase
+
+from unilabos.utils.log import logger
+
+
+class WorkflowExecutor(ABC):
+    """工作流执行器基类 - 基于单一硬件接口"""
+    
+    def __init__(self, workstation: 'WorkstationBase'):
+        self.workstation = workstation
+        self.hardware_interface = workstation.hardware_interface
+        self.material_management = workstation.material_management
+    
+    @abstractmethod
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行工作流"""
+        pass
+    
+    @abstractmethod
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止工作流"""
+        pass
+    
+    def call_device(self, method: str, *args, **kwargs) -> Any:
+        """调用设备方法的统一接口"""
+        return self.workstation.call_device_method(method, *args, **kwargs)
+    
+    def get_device_status(self) -> Dict[str, Any]:
+        """获取设备状态"""
+        return self.workstation.get_device_status()
+
+
+class ModbusWorkflowExecutor(WorkflowExecutor):
+    """Modbus工作流执行器 - 适配 coin_cell_assembly_system"""
+    
+    def __init__(self, workstation: 'WorkstationBase'):
+        super().__init__(workstation)
+        
+        # 验证Modbus接口
+        if not (hasattr(self.hardware_interface, 'write_register') and 
+                hasattr(self.hardware_interface, 'read_register')):
+            raise RuntimeError("工作站硬件接口不是有效的Modbus客户端")
+    
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行Modbus工作流"""
+        if workflow_name == "battery_manufacturing":
+            return self._execute_battery_manufacturing(parameters)
+        elif workflow_name == "material_loading":
+            return self._execute_material_loading(parameters)
+        elif workflow_name == "quality_check":
+            return self._execute_quality_check(parameters)
+        else:
+            logger.warning(f"不支持的Modbus工作流: {workflow_name}")
+            return False
+    
+    def _execute_battery_manufacturing(self, parameters: Dict[str, Any]) -> bool:
+        """执行电池制造工作流"""
+        try:
+            # 1. 物料准备检查
+            available_slot = self._find_available_press_slot()
+            if not available_slot:
+                raise RuntimeError("没有可用的压制槽")
+            
+            logger.info(f"找到可用压制槽: {available_slot}")
+            
+            # 2. 设置工艺参数（直接调用Modbus接口）
+            if "electrolyte_num" in parameters:
+                self.hardware_interface.write_register('REG_MSG_ELECTROLYTE_NUM', parameters["electrolyte_num"])
+                logger.info(f"设置电解液编号: {parameters['electrolyte_num']}")
+            
+            if "electrolyte_volume" in parameters:
+                self.hardware_interface.write_register('REG_MSG_ELECTROLYTE_VOLUME', 
+                                                      parameters["electrolyte_volume"], 
+                                                      data_type="FLOAT32")
+                logger.info(f"设置电解液体积: {parameters['electrolyte_volume']}")
+            
+            if "assembly_pressure" in parameters:
+                self.hardware_interface.write_register('REG_MSG_ASSEMBLY_PRESSURE',
+                                                      parameters["assembly_pressure"],
+                                                      data_type="FLOAT32")
+                logger.info(f"设置装配压力: {parameters['assembly_pressure']}")
+            
+            # 3. 启动制造流程
+            self.hardware_interface.write_register('COIL_SYS_START_CMD', True)
+            logger.info("启动电池制造流程")
+            
+            # 4. 确认启动成功
+            time.sleep(0.5)
+            status = self.hardware_interface.read_register('COIL_SYS_START_STATUS', count=1)
+            success = status[0] if status else False
+            
+            if success:
+                logger.info(f"电池制造工作流启动成功，参数: {parameters}")
+            else:
+                logger.error("电池制造工作流启动失败")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"执行电池制造工作流失败: {e}")
+            return False
+    
+    def _execute_material_loading(self, parameters: Dict[str, Any]) -> bool:
+        """执行物料装载工作流"""
+        try:
+            material_type = parameters.get('material_type', 'cathode')
+            position = parameters.get('position', 'A1')
+            
+            logger.info(f"开始物料装载: {material_type} -> {position}")
+            
+            # 设置物料类型和位置
+            self.hardware_interface.write_register('REG_MATERIAL_TYPE', material_type)
+            self.hardware_interface.write_register('REG_MATERIAL_POSITION', position)
+            
+            # 启动装载
+            self.hardware_interface.write_register('COIL_LOAD_START', True)
+            
+            # 等待装载完成
+            timeout = parameters.get('timeout', 30)
+            start_time = time.time()
+            
+            while time.time() - start_time < timeout:
+                status = self.hardware_interface.read_register('COIL_LOAD_COMPLETE', count=1)
+                if status and status[0]:
+                    logger.info(f"物料装载完成: {material_type} -> {position}")
+                    return True
+                time.sleep(0.5)
+            
+            logger.error(f"物料装载超时: {material_type} -> {position}")
+            return False
+            
+        except Exception as e:
+            logger.error(f"执行物料装载失败: {e}")
+            return False
+    
+    def _execute_quality_check(self, parameters: Dict[str, Any]) -> bool:
+        """执行质量检测工作流"""
+        try:
+            check_type = parameters.get('check_type', 'dimensional')
+            
+            logger.info(f"开始质量检测: {check_type}")
+            
+            # 启动质量检测
+            self.hardware_interface.write_register('REG_QC_TYPE', check_type)
+            self.hardware_interface.write_register('COIL_QC_START', True)
+            
+            # 等待检测完成
+            timeout = parameters.get('timeout', 60)
+            start_time = time.time()
+            
+            while time.time() - start_time < timeout:
+                status = self.hardware_interface.read_register('COIL_QC_COMPLETE', count=1)
+                if status and status[0]:
+                    # 读取检测结果
+                    result = self.hardware_interface.read_register('REG_QC_RESULT', count=1)
+                    passed = result[0] if result else False
+                    
+                    if passed:
+                        logger.info(f"质量检测通过: {check_type}")
+                        return True
+                    else:
+                        logger.warning(f"质量检测失败: {check_type}")
+                        return False
+                        
+                time.sleep(1.0)
+            
+            logger.error(f"质量检测超时: {check_type}")
+            return False
+            
+        except Exception as e:
+            logger.error(f"执行质量检测失败: {e}")
+            return False
+    
+    def _find_available_press_slot(self) -> Optional[str]:
+        """查找可用压制槽"""
+        try:
+            press_slots = self.material_management.find_by_category("battery_press_slot")
+            for slot in press_slots:
+                if hasattr(slot, 'has_battery') and not slot.has_battery():
+                    return slot.name
+            return None
+        except:
+            # 如果物料管理系统不可用，返回默认槽位
+            return "A1"
+    
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止工作流"""
+        try:
+            if emergency:
+                self.hardware_interface.write_register('COIL_SYS_RESET_CMD', True)
+                logger.warning("执行紧急停止")
+            else:
+                self.hardware_interface.write_register('COIL_SYS_STOP_CMD', True)
+                logger.info("执行正常停止")
+            
+            time.sleep(0.5)
+            status = self.hardware_interface.read_register('COIL_SYS_STOP_STATUS', count=1)
+            return status[0] if status else False
+            
+        except Exception as e:
+            logger.error(f"停止Modbus工作流失败: {e}")
+            return False
+
+
+class HttpWorkflowExecutor(WorkflowExecutor):
+    """HTTP工作流执行器 - 适配 reaction_station_bioyong"""
+    
+    def __init__(self, workstation: 'WorkstationBase'):
+        super().__init__(workstation)
+        
+        # 验证HTTP接口
+        if not (hasattr(self.hardware_interface, 'post') or 
+                hasattr(self.hardware_interface, 'get')):
+            raise RuntimeError("工作站硬件接口不是有效的HTTP客户端")
+    
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行HTTP工作流"""
+        try:
+            if workflow_name == "reaction_synthesis":
+                return self._execute_reaction_synthesis(parameters)
+            elif workflow_name == "liquid_feeding":
+                return self._execute_liquid_feeding(parameters)
+            elif workflow_name == "temperature_control":
+                return self._execute_temperature_control(parameters)
+            else:
+                logger.warning(f"不支持的HTTP工作流: {workflow_name}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"执行HTTP工作流失败: {e}")
+            return False
+    
+    def _execute_reaction_synthesis(self, parameters: Dict[str, Any]) -> bool:
+        """执行反应合成工作流"""
+        try:
+            # 1. 设置工作流序列
+            sequence = self._build_reaction_sequence(parameters)
+            self._call_rpc_method('set_workflow_sequence', json.dumps(sequence))
+            
+            # 2. 设置反应参数
+            if parameters.get('temperature'):
+                self._call_rpc_method('set_temperature', parameters['temperature'])
+            
+            if parameters.get('pressure'):
+                self._call_rpc_method('set_pressure', parameters['pressure'])
+            
+            if parameters.get('stirring_speed'):
+                self._call_rpc_method('set_stirring_speed', parameters['stirring_speed'])
+            
+            # 3. 执行工作流
+            result = self._call_rpc_method('execute_current_sequence', {
+                "task_name": "reaction_synthesis"
+            })
+            
+            success = result.get('success', False)
+            if success:
+                logger.info("反应合成工作流执行成功")
+            else:
+                logger.error(f"反应合成工作流执行失败: {result.get('error', '未知错误')}")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"执行反应合成工作流失败: {e}")
+            return False
+    
+    def _execute_liquid_feeding(self, parameters: Dict[str, Any]) -> bool:
+        """执行液体投料工作流"""
+        try:
+            reagents = parameters.get('reagents', [])
+            volumes = parameters.get('volumes', [])
+            
+            if len(reagents) != len(volumes):
+                raise ValueError("试剂列表和体积列表长度不匹配")
+            
+            # 执行投料序列
+            for reagent, volume in zip(reagents, volumes):
+                result = self._call_rpc_method('feed_liquid', {
+                    'reagent': reagent,
+                    'volume': volume
+                })
+                
+                if not result.get('success', False):
+                    logger.error(f"投料失败: {reagent} {volume}mL")
+                    return False
+                
+                logger.info(f"投料成功: {reagent} {volume}mL")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"执行液体投料失败: {e}")
+            return False
+    
+    def _execute_temperature_control(self, parameters: Dict[str, Any]) -> bool:
+        """执行温度控制工作流"""
+        try:
+            target_temp = parameters.get('temperature', 25)
+            hold_time = parameters.get('hold_time', 300)  # 秒
+            
+            # 设置目标温度
+            result = self._call_rpc_method('set_temperature', target_temp)
+            if not result.get('success', False):
+                logger.error(f"设置温度失败: {target_temp}°C")
+                return False
+            
+            # 等待温度稳定
+            logger.info(f"等待温度稳定到 {target_temp}°C")
+            
+            # 保持温度指定时间
+            if hold_time > 0:
+                logger.info(f"保持温度 {hold_time} 秒")
+                time.sleep(hold_time)
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"执行温度控制失败: {e}")
+            return False
+    
+    def _build_reaction_sequence(self, parameters: Dict[str, Any]) -> List[str]:
+        """构建反应合成工作流序列"""
+        sequence = []
+        
+        # 添加预处理步骤
+        if parameters.get('purge_with_inert'):
+            sequence.append("purge_inert_gas")
+        
+        # 添加温度设置
+        if parameters.get('temperature'):
+            sequence.append(f"set_temperature_{parameters['temperature']}")
+        
+        # 添加压力设置
+        if parameters.get('pressure'):
+            sequence.append(f"set_pressure_{parameters['pressure']}")
+        
+        # 添加搅拌设置
+        if parameters.get('stirring_speed'):
+            sequence.append(f"set_stirring_{parameters['stirring_speed']}")
+        
+        # 添加反应步骤
+        sequence.extend([
+            "start_reaction",
+            "monitor_progress", 
+            "complete_reaction"
+        ])
+        
+        # 添加后处理步骤
+        if parameters.get('cooling_required'):
+            sequence.append("cool_down")
+        
+        return sequence
+    
+    def _call_rpc_method(self, method: str, params: Any = None) -> Dict[str, Any]:
+        """调用RPC方法"""
+        try:
+            if hasattr(self.hardware_interface, method):
+                # 直接方法调用
+                if isinstance(params, dict):
+                    params = json.dumps(params)
+                elif params is None:
+                    params = ""
+                return getattr(self.hardware_interface, method)(params)
+            else:
+                # HTTP请求调用
+                if hasattr(self.hardware_interface, 'post'):
+                    response = self.hardware_interface.post(f"/api/{method}", json=params)
+                    return response.json()
+                else:
+                    raise AttributeError(f"HTTP接口不支持方法: {method}")
+        except Exception as e:
+            logger.error(f"调用RPC方法失败 {method}: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止工作流"""
+        try:
+            if emergency:
+                result = self._call_rpc_method('scheduler_reset')
+            else:
+                result = self._call_rpc_method('scheduler_stop')
+            
+            return result.get('success', False)
+            
+        except Exception as e:
+            logger.error(f"停止HTTP工作流失败: {e}")
+            return False
+
+
+class PyLabRobotWorkflowExecutor(WorkflowExecutor):
+    """PyLabRobot工作流执行器 - 适配 prcxi.py"""
+    
+    def __init__(self, workstation: 'WorkstationBase'):
+        super().__init__(workstation)
+        
+        # 验证PyLabRobot接口
+        if not (hasattr(self.hardware_interface, 'transfer_liquid') or 
+                hasattr(self.hardware_interface, 'pickup_tips')):
+            raise RuntimeError("工作站硬件接口不是有效的PyLabRobot设备")
+    
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行PyLabRobot工作流"""
+        try:
+            if workflow_name == "liquid_transfer":
+                return self._execute_liquid_transfer(parameters)
+            elif workflow_name == "tip_pickup_drop":
+                return self._execute_tip_operations(parameters)
+            elif workflow_name == "plate_handling":
+                return self._execute_plate_handling(parameters)
+            else:
+                logger.warning(f"不支持的PyLabRobot工作流: {workflow_name}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"执行PyLabRobot工作流失败: {e}")
+            return False
+    
+    def _execute_liquid_transfer(self, parameters: Dict[str, Any]) -> bool:
+        """执行液体转移工作流"""
+        try:
+            # 1. 解析物料引用
+            sources = self._resolve_containers(parameters.get('sources', []))
+            targets = self._resolve_containers(parameters.get('targets', []))
+            tip_racks = self._resolve_tip_racks(parameters.get('tip_racks', []))
+            
+            if not sources or not targets:
+                raise ValueError("液体转移需要指定源容器和目标容器")
+            
+            if not tip_racks:
+                logger.warning("未指定枪头架，将尝试自动查找")
+                tip_racks = self._find_available_tip_racks()
+            
+            # 2. 执行液体转移
+            volumes = parameters.get('volumes', [])
+            if not volumes:
+                volumes = [100.0] * len(sources)  # 默认体积
+            
+            # 如果是同步接口
+            if hasattr(self.hardware_interface, 'transfer_liquid'):
+                result = self.hardware_interface.transfer_liquid(
+                    sources=sources,
+                    targets=targets,
+                    tip_racks=tip_racks,
+                    asp_vols=volumes,
+                    dis_vols=volumes,
+                    **parameters.get('options', {})
+                )
+            else:
+                # 异步接口需要特殊处理
+                asyncio.run(self._async_liquid_transfer(sources, targets, tip_racks, volumes, parameters))
+                result = True
+            
+            if result:
+                logger.info(f"液体转移工作流完成: {len(sources)}个源 -> {len(targets)}个目标")
+            
+            return bool(result)
+            
+        except Exception as e:
+            logger.error(f"执行液体转移失败: {e}")
+            return False
+    
+    async def _async_liquid_transfer(self, sources, targets, tip_racks, volumes, parameters):
+        """异步液体转移"""
+        await self.hardware_interface.transfer_liquid(
+            sources=sources,
+            targets=targets,
+            tip_racks=tip_racks,
+            asp_vols=volumes,
+            dis_vols=volumes,
+            **parameters.get('options', {})
+        )
+    
+    def _execute_tip_operations(self, parameters: Dict[str, Any]) -> bool:
+        """执行枪头操作工作流"""
+        try:
+            operation = parameters.get('operation', 'pickup')
+            tip_racks = self._resolve_tip_racks(parameters.get('tip_racks', []))
+            
+            if not tip_racks:
+                raise ValueError("枪头操作需要指定枪头架")
+            
+            if operation == 'pickup':
+                result = self.hardware_interface.pickup_tips(tip_racks[0])
+                logger.info("枪头拾取完成")
+            elif operation == 'drop':
+                result = self.hardware_interface.drop_tips()
+                logger.info("枪头丢弃完成")
+            else:
+                raise ValueError(f"不支持的枪头操作: {operation}")
+            
+            return bool(result)
+            
+        except Exception as e:
+            logger.error(f"执行枪头操作失败: {e}")
+            return False
+    
+    def _execute_plate_handling(self, parameters: Dict[str, Any]) -> bool:
+        """执行板类处理工作流"""
+        try:
+            operation = parameters.get('operation', 'move')
+            source_position = parameters.get('source_position')
+            target_position = parameters.get('target_position')
+            
+            if operation == 'move' and source_position and target_position:
+                # 移动板类
+                result = self.hardware_interface.move_plate(source_position, target_position)
+                logger.info(f"板类移动完成: {source_position} -> {target_position}")
+            else:
+                logger.warning(f"不支持的板类操作或参数不完整: {operation}")
+                return False
+            
+            return bool(result)
+            
+        except Exception as e:
+            logger.error(f"执行板类处理失败: {e}")
+            return False
+    
+    def _resolve_containers(self, container_names: List[str]):
+        """解析容器名称为实际容器对象"""
+        containers = []
+        for name in container_names:
+            try:
+                container = self.material_management.find_material_by_id(name)
+                if container:
+                    containers.append(container)
+                else:
+                    logger.warning(f"未找到容器: {name}")
+            except:
+                logger.warning(f"解析容器失败: {name}")
+        return containers
+    
+    def _resolve_tip_racks(self, tip_rack_names: List[str]):
+        """解析枪头架名称为实际对象"""
+        tip_racks = []
+        for name in tip_rack_names:
+            try:
+                tip_rack = self.material_management.find_by_category("tip_rack")
+                matching_racks = [rack for rack in tip_rack if rack.name == name]
+                if matching_racks:
+                    tip_racks.extend(matching_racks)
+                else:
+                    logger.warning(f"未找到枪头架: {name}")
+            except:
+                logger.warning(f"解析枪头架失败: {name}")
+        return tip_racks
+    
+    def _find_available_tip_racks(self):
+        """查找可用的枪头架"""
+        try:
+            tip_racks = self.material_management.find_by_category("tip_rack")
+            available_racks = [rack for rack in tip_racks if hasattr(rack, 'has_tips') and rack.has_tips()]
+            return available_racks[:1]  # 返回第一个可用的枪头架
+        except:
+            return []
+    
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止工作流"""
+        try:
+            if emergency:
+                if hasattr(self.hardware_interface, 'emergency_stop'):
+                    return self.hardware_interface.emergency_stop()
+                else:
+                    logger.warning("设备不支持紧急停止")
+                    return False
+            else:
+                if hasattr(self.hardware_interface, 'graceful_stop'):
+                    return self.hardware_interface.graceful_stop()
+                elif hasattr(self.hardware_interface, 'stop'):
+                    return self.hardware_interface.stop()
+                else:
+                    logger.warning("设备不支持优雅停止")
+                    return False
+                
+        except Exception as e:
+            logger.error(f"停止PyLabRobot工作流失败: {e}")
+            return False
+
+
+class ProxyWorkflowExecutor(WorkflowExecutor):
+    """代理工作流执行器 - 处理代理模式的工作流"""
+    
+    def __init__(self, workstation: 'WorkstationBase'):
+        super().__init__(workstation)
+        
+        # 验证代理接口
+        if not isinstance(self.hardware_interface, str) or not self.hardware_interface.startswith("proxy:"):
+            raise RuntimeError("工作站硬件接口不是有效的代理字符串")
+        
+        self.device_id = self.hardware_interface[6:]  # 移除 "proxy:" 前缀
+    
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行代理工作流"""
+        try:
+            # 通过协议节点调用目标设备的工作流
+            if self.workstation._workstation_node:
+                return self.workstation._workstation_node.call_device_method(
+                    self.device_id, 'execute_workflow', workflow_name, parameters
+                )
+            else:
+                logger.error("代理模式需要workstation_node")
+                return False
+                
+        except Exception as e:
+            logger.error(f"执行代理工作流失败: {e}")
+            return False
+    
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止代理工作流"""
+        try:
+            if self.workstation._workstation_node:
+                return self.workstation._workstation_node.call_device_method(
+                    self.device_id, 'stop_workflow', emergency
+                )
+            else:
+                logger.error("代理模式需要workstation_node")
+                return False
+                
+        except Exception as e:
+            logger.error(f"停止代理工作流失败: {e}")
+            return False
+
+
+# 辅助函数
+def get_executor_for_interface(hardware_interface) -> str:
+    """根据硬件接口类型获取执行器类型名称"""
+    if isinstance(hardware_interface, str) and hardware_interface.startswith("proxy:"):
+        return "ProxyWorkflowExecutor"
+    elif hasattr(hardware_interface, 'write_register') and hasattr(hardware_interface, 'read_register'):
+        return "ModbusWorkflowExecutor"
+    elif hasattr(hardware_interface, 'post') or hasattr(hardware_interface, 'get'):
+        return "HttpWorkflowExecutor"
+    elif hasattr(hardware_interface, 'transfer_liquid') or hasattr(hardware_interface, 'pickup_tips'):
+        return "PyLabRobotWorkflowExecutor"
+    else:
+        return "UnknownExecutor"

unilabos/devices/workstation/workstation_base.py

@@ -0,0 +1,489 @@
+"""
+工作站基类
+Workstation Base Class - 简化版
+
+基于PLR Deck的简化工作站架构
+专注于核心物料系统和工作流管理
+"""
+
+import collections
+import time
+from typing import Dict, Any, List, Optional, Union
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from pylabrobot.resources import Deck, Plate, Resource as PLRResource
+
+from pylabrobot.resources.coordinate import Coordinate
+from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
+
+from unilabos.utils.log import logger
+
+
+class WorkflowStatus(Enum):
+    """工作流状态"""
+
+    IDLE = "idle"
+    INITIALIZING = "initializing"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+    COMPLETED = "completed"
+
+
+@dataclass
+class WorkflowInfo:
+    """工作流信息"""
+
+    name: str
+    description: str
+    estimated_duration: float  # 预估持续时间（秒）
+    required_materials: List[str]  # 所需物料类型
+    output_product: str  # 输出产品类型
+    parameters_schema: Dict[str, Any]  # 参数架构
+
+
+class WorkStationContainer(Plate):
+    """
+    WorkStation 专用 Container 类，继承自 Plate和TipRack
+    注意这个物料必须通过plr_additional_res_reg.py注册到edge，才能正常序列化
+    """
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        category: str,
+        ordering: collections.OrderedDict,
+        model: Optional[str] = None,
+    ):
+        """
+        这里的初始化入参要和plr的保持一致
+        """
+        super().__init__(name, size_x, size_y, size_z, category=category, ordering=ordering, model=model)
+        self._unilabos_state = {}  # 必须有此行，自己的类描述的是物料的
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """从给定的状态加载工作台信息。"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        data = super().serialize_state()
+        data.update(
+            self._unilabos_state
+        )  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
+        return data
+
+
+def get_workstation_plate_resource(name: str) -> PLRResource:  # 要给定一个返回plr的方法
+    """
+    用于获取一些模板，例如返回一个带有特定信息/子物料的 Plate，这里需要到注册表注册，例如unilabos/registry/resources/organic/workstation.yaml
+    可以直接运行该函数或者利用注册表补全机制，来检查是否资源出错
+    :param name: 资源名称
+    :return: Resource对象
+    """
+    plate = WorkStationContainer(
+        name, size_x=50, size_y=50, size_z=10, category="plate", ordering=collections.OrderedDict()
+    )
+    tip_rack = WorkStationContainer(
+        "tip_rack_inside_plate",
+        size_x=50,
+        size_y=50,
+        size_z=10,
+        category="tip_rack",
+        ordering=collections.OrderedDict(),
+    )
+    plate.assign_child_resource(tip_rack, Coordinate.zero())
+    return plate
+
+
+class ResourceSynchronizer(ABC):
+    """资源同步器基类
+
+    负责与外部物料系统的同步，并对 self.deck 做修改
+    """
+
+    def __init__(self, workstation: "WorkstationBase"):
+        self.workstation = workstation
+
+    @abstractmethod
+    async def sync_from_external(self) -> bool:
+        """从外部系统同步物料到本地deck"""
+        pass
+
+    @abstractmethod
+    async def sync_to_external(self, plr_resource: PLRResource) -> bool:
+        """将本地物料同步到外部系统"""
+        pass
+
+    @abstractmethod
+    async def handle_external_change(self, change_info: Dict[str, Any]) -> bool:
+        """处理外部系统的变更通知"""
+        pass
+
+
+class WorkstationBase(ABC):
+    """工作站基类 - 简化版
+
+    核心功能：
+    1. 基于 PLR Deck 的物料系统，支持格式转换
+    2. 可选的资源同步器支持外部物料系统
+    3. 简化的工作流管理
+    """
+
+    _ros_node: ROS2WorkstationNode
+
+    @property
+    def _children(self) -> Dict[str, Any]:  # 不要删除这个下划线，不然会自动导入注册表，后面改成装饰器识别
+        return self._ros_node.children
+
+    async def update_resource_example(self):
+        return await self._ros_node.update_resource([get_workstation_plate_resource("test")])
+
+    def __init__(
+        self,
+        station_resource: PLRResource,
+        *args,
+        **kwargs,  # 必须有kwargs
+    ):
+        # 基本配置
+        print(station_resource)
+        self.deck_config = station_resource
+
+        # PLR 物料系统
+        self.deck: Optional[Deck] = None
+        self.plr_resources: Dict[str, PLRResource] = {}
+
+        # 资源同步器（可选）
+        # self.resource_synchronizer = ResourceSynchronizer(self)  # 要在driver中自行初始化，只有workstation用
+
+        # 硬件接口
+        self.hardware_interface: Union[Any, str] = None
+
+        # 工作流状态
+        self.current_workflow_status = WorkflowStatus.IDLE
+        self.current_workflow_info = None
+        self.workflow_start_time = None
+        self.workflow_parameters = {}
+
+        # 支持的工作流（静态预定义）
+        self.supported_workflows: Dict[str, WorkflowInfo] = {}
+
+        # 初始化物料系统
+        self._initialize_material_system()
+
+        # 注册支持的工作流
+        # self._register_supported_workflows()
+
+        # logger.info(f"工作站 {device_id} 初始化完成（简化版）")
+
+    def _initialize_material_system(self):
+        """初始化物料系统 - 使用 graphio 转换"""
+        try:
+            from unilabos.resources.graphio import resource_ulab_to_plr
+
+            # # 1. 合并 deck_config 和 children 创建完整的资源树
+            # complete_resource_config = self._create_complete_resource_config()
+
+            # # 2. 使用 graphio 转换为 PLR 资源
+            # self.deck = resource_ulab_to_plr(complete_resource_config, plr_model=True)
+
+            # # 3. 建立资源映射
+            # self._build_resource_mappings(self.deck)
+
+            # # 4. 如果有资源同步器，执行初始同步
+            # if self.resource_synchronizer:
+            #     # 这里可以异步执行，暂时跳过
+            #     pass
+
+            # logger.info(f"工作站 {self.device_id} 物料系统初始化成功，创建了 {len(self.plr_resources)} 个资源")
+            pass
+        except Exception as e:
+            # logger.error(f"工作站 {self.device_id} 物料系统初始化失败: {e}")
+            raise
+
+    def _create_complete_resource_config(self) -> Dict[str, Any]:
+        """创建完整的资源配置 - 合并 deck_config 和 children"""
+        # 创建主 deck 配置
+        deck_resource = {
+            "id": f"{self.device_id}_deck",
+            "name": f"{self.device_id}_deck",
+            "type": "deck",
+            "position": {"x": 0, "y": 0, "z": 0},
+            "config": {
+                "size_x": self.deck_config.get("size_x", 1000.0),
+                "size_y": self.deck_config.get("size_y", 1000.0),
+                "size_z": self.deck_config.get("size_z", 100.0),
+                **{k: v for k, v in self.deck_config.items() if k not in ["size_x", "size_y", "size_z"]},
+            },
+            "data": {},
+            "children": [],
+            "parent": None,
+        }
+
+        # 添加子资源
+        if self._children:
+            children_list = []
+            for child_id, child_config in self._children.items():
+                child_resource = self._normalize_child_resource(child_id, child_config, deck_resource["id"])
+                children_list.append(child_resource)
+            deck_resource["children"] = children_list
+
+        return deck_resource
+
+    def _normalize_child_resource(self, resource_id: str, config: Dict[str, Any], parent_id: str) -> Dict[str, Any]:
+        """标准化子资源配置"""
+        return {
+            "id": resource_id,
+            "name": config.get("name", resource_id),
+            "type": config.get("type", "container"),
+            "position": self._normalize_position(config.get("position", {})),
+            "config": config.get("config", {}),
+            "data": config.get("data", {}),
+            "children": [],  # 简化版本：只支持一层子资源
+            "parent": parent_id,
+        }
+
+    def _normalize_position(self, position: Any) -> Dict[str, float]:
+        """标准化位置信息"""
+        if isinstance(position, dict):
+            return {
+                "x": float(position.get("x", 0)),
+                "y": float(position.get("y", 0)),
+                "z": float(position.get("z", 0)),
+            }
+        elif isinstance(position, (list, tuple)) and len(position) >= 2:
+            return {
+                "x": float(position[0]),
+                "y": float(position[1]),
+                "z": float(position[2]) if len(position) > 2 else 0.0,
+            }
+        else:
+            return {"x": 0.0, "y": 0.0, "z": 0.0}
+
+    def _build_resource_mappings(self, deck: Deck):
+        """递归构建资源映射"""
+
+        def add_resource_recursive(resource: PLRResource):
+            if hasattr(resource, "name"):
+                self.plr_resources[resource.name] = resource
+
+            if hasattr(resource, "children"):
+                for child in resource.children:
+                    add_resource_recursive(child)
+
+        add_resource_recursive(deck)
+
+    # ============ 硬件接口管理 ============
+
+    def set_hardware_interface(self, hardware_interface: Union[Any, str]):
+        """设置硬件接口"""
+        self.hardware_interface = hardware_interface
+        logger.info(f"工作站 {self.device_id} 硬件接口设置: {type(hardware_interface).__name__}")
+
+    def set_workstation_node(self, workstation_node: "ROS2WorkstationNode"):
+        """设置协议节点引用（用于代理模式）"""
+        self._ros_node = workstation_node
+        logger.info(f"工作站 {self.device_id} 关联协议节点")
+
+    # ============ 设备操作接口 ============
+
+    def call_device_method(self, method: str, *args, **kwargs) -> Any:
+        """调用设备方法的统一接口"""
+        # 1. 代理模式：通过协议节点转发
+        if isinstance(self.hardware_interface, str) and self.hardware_interface.startswith("proxy:"):
+            if not self._ros_node:
+                raise RuntimeError("代理模式需要设置workstation_node")
+
+            device_id = self.hardware_interface[6:]  # 移除 "proxy:" 前缀
+            return self._ros_node.call_device_method(device_id, method, *args, **kwargs)
+
+        # 2. 直接模式：直接调用硬件接口方法
+        elif self.hardware_interface and hasattr(self.hardware_interface, method):
+            return getattr(self.hardware_interface, method)(*args, **kwargs)
+
+        else:
+            raise AttributeError(f"硬件接口不支持方法: {method}")
+
+    def get_device_status(self) -> Dict[str, Any]:
+        """获取设备状态"""
+        try:
+            return self.call_device_method("get_status")
+        except AttributeError:
+            # 如果设备不支持get_status方法，返回基础状态
+            return {
+                "status": "unknown",
+                "interface_type": type(self.hardware_interface).__name__,
+                "timestamp": time.time(),
+            }
+
+    def is_device_available(self) -> bool:
+        """检查设备是否可用"""
+        try:
+            self.get_device_status()
+            return True
+        except:
+            return False
+
+    # ============ 物料系统接口 ============
+
+    def get_deck(self) -> Deck:
+        """获取主 Deck"""
+        return self.deck
+
+    def get_all_resources(self) -> Dict[str, PLRResource]:
+        """获取所有 PLR 资源"""
+        return self.plr_resources.copy()
+
+    def find_resource_by_name(self, name: str) -> Optional[PLRResource]:
+        """按名称查找资源"""
+        return self.plr_resources.get(name)
+
+    def find_resources_by_type(self, resource_type: type) -> List[PLRResource]:
+        """按类型查找资源"""
+        return [res for res in self.plr_resources.values() if isinstance(res, resource_type)]
+
+    async def sync_with_external_system(self) -> bool:
+        """与外部物料系统同步"""
+        if not self.resource_synchronizer:
+            logger.info(f"工作站 {self.device_id} 没有配置资源同步器")
+            return True
+
+        try:
+            success = await self.resource_synchronizer.sync_from_external()
+            if success:
+                logger.info(f"工作站 {self.device_id} 外部同步成功")
+            else:
+                logger.warning(f"工作站 {self.device_id} 外部同步失败")
+            return success
+        except Exception as e:
+            logger.error(f"工作站 {self.device_id} 外部同步异常: {e}")
+            return False
+
+    # ============ 简化的工作流控制 ============
+
+    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行工作流"""
+        try:
+            # 设置工作流状态
+            self.current_workflow_status = WorkflowStatus.INITIALIZING
+            self.workflow_parameters = parameters
+            self.workflow_start_time = time.time()
+
+            # 委托给子类实现
+            success = self._execute_workflow_impl(workflow_name, parameters)
+
+            if success:
+                self.current_workflow_status = WorkflowStatus.RUNNING
+                logger.info(f"工作站 {self.device_id} 工作流 {workflow_name} 启动成功")
+            else:
+                self.current_workflow_status = WorkflowStatus.ERROR
+                logger.error(f"工作站 {self.device_id} 工作流 {workflow_name} 启动失败")
+
+            return success
+
+        except Exception as e:
+            self.current_workflow_status = WorkflowStatus.ERROR
+            logger.error(f"工作站 {self.device_id} 执行工作流失败: {e}")
+            return False
+
+    def stop_workflow(self, emergency: bool = False) -> bool:
+        """停止工作流"""
+        try:
+            if self.current_workflow_status in [WorkflowStatus.IDLE, WorkflowStatus.STOPPED]:
+                logger.warning(f"工作站 {self.device_id} 没有正在运行的工作流")
+                return True
+
+            self.current_workflow_status = WorkflowStatus.STOPPING
+
+            # 委托给子类实现
+            success = self._stop_workflow_impl(emergency)
+
+            if success:
+                self.current_workflow_status = WorkflowStatus.STOPPED
+                logger.info(f"工作站 {self.device_id} 工作流停止成功 (紧急: {emergency})")
+            else:
+                self.current_workflow_status = WorkflowStatus.ERROR
+                logger.error(f"工作站 {self.device_id} 工作流停止失败")
+
+            return success
+
+        except Exception as e:
+            self.current_workflow_status = WorkflowStatus.ERROR
+            logger.error(f"工作站 {self.device_id} 停止工作流失败: {e}")
+            return False
+
+    # ============ 状态属性 ============
+
+    @property
+    def workflow_status(self) -> WorkflowStatus:
+        """获取当前工作流状态"""
+        return self.current_workflow_status
+
+    @property
+    def is_busy(self) -> bool:
+        """检查工作站是否忙碌"""
+        return self.current_workflow_status in [
+            WorkflowStatus.INITIALIZING,
+            WorkflowStatus.RUNNING,
+            WorkflowStatus.STOPPING,
+        ]
+
+    @property
+    def workflow_runtime(self) -> float:
+        """获取工作流运行时间（秒）"""
+        if self.workflow_start_time is None:
+            return 0.0
+        return time.time() - self.workflow_start_time
+
+    # ============ 抽象方法 - 子类必须实现 ============
+
+    # @abstractmethod
+    # def _register_supported_workflows(self):
+    #     """注册支持的工作流 - 子类必须实现"""
+    #     pass
+
+    # @abstractmethod
+    # def _execute_workflow_impl(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+    #     """执行工作流的具体实现 - 子类必须实现"""
+    #     pass
+
+    # @abstractmethod
+    # def _stop_workflow_impl(self, emergency: bool = False) -> bool:
+    #     """停止工作流的具体实现 - 子类必须实现"""
+    #     pass
+
+class WorkstationExample(WorkstationBase):
+    """工作站示例实现"""
+
+    def _register_supported_workflows(self):
+        """注册支持的工作流"""
+        self.supported_workflows["example_workflow"] = WorkflowInfo(
+            name="example_workflow",
+            description="这是一个示例工作流",
+            estimated_duration=300.0,
+            required_materials=["sample_plate"],
+            output_product="processed_plate",
+            parameters_schema={"param1": "string", "param2": "integer"},
+        )
+
+    def _execute_workflow_impl(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
+        """执行工作流的具体实现"""
+        if workflow_name not in self.supported_workflows:
+            logger.error(f"工作站 {self.device_id} 不支持工作流: {workflow_name}")
+            return False
+
+        # 这里添加实际的工作流逻辑
+        logger.info(f"工作站 {self.device_id} 正在执行工作流: {workflow_name} with parameters {parameters}")
+        return True
+
+    def _stop_workflow_impl(self, emergency: bool = False) -> bool:
+        """停止工作流的具体实现"""
+        # 这里添加实际的停止逻辑
+        logger.info(f"工作站 {self.device_id} 正在停止工作流 (紧急: {emergency})")
+        return True

unilabos/devices/workstation/workstation_http_service.py

@@ -0,0 +1,605 @@
+"""
+工作站HTTP服务模块
+Workstation HTTP Service Module
+
+统一的工作站报送接收服务，基于LIMS协议规范：
+1. 步骤完成报送 - POST /report/step_finish
+2. 通量完成报送 - POST /report/sample_finish  
+3. 任务完成报送 - POST /report/order_finish
+4. 批量更新报送 - POST /report/batch_update
+5. 物料变更报送 - POST /report/material_change
+6. 错误处理报送 - POST /report/error_handling
+7. 健康检查和状态查询
+
+统一使用LIMS协议字段规范，简化接口避免功能重复
+"""
+import json
+import threading
+import time
+import traceback
+from typing import Dict, Any, Optional, List
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import urlparse
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+from unilabos.utils.log import logger
+
+
+@dataclass
+class WorkstationReportRequest:
+    """统一工作站报送请求（基于LIMS协议规范）"""
+    token: str                     # 授权令牌
+    request_time: str              # 请求时间，格式：2024-12-12 12:12:12.xxx
+    data: Dict[str, Any]           # 报送数据
+
+
+@dataclass
+class MaterialUsage:
+    """物料使用记录"""
+    materialId: str                # 物料Id（GUID）
+    locationId: str                # 库位Id（GUID）
+    typeMode: str                  # 物料类型（样品1、试剂2、耗材0）
+    usedQuantity: float            # 使用的数量（数字）
+
+
+@dataclass
+class HttpResponse:
+    """HTTP响应"""
+    success: bool
+    message: str
+    data: Optional[Dict[str, Any]] = None
+    acknowledgment_id: Optional[str] = None
+
+
+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:
+                post_data = self.rfile.read(content_length)
+                request_data = json.loads(post_data.decode('utf-8'))
+            else:
+                request_data = {}
+            
+            logger.info(f"收到工作站报送: {endpoint} - {request_data.get('token', 'unknown')}")
+            
+            # 统一的报送端点路由（基于LIMS协议规范）
+            if endpoint == '/report/step_finish':
+                response = self._handle_step_finish_report(request_data)
+            elif endpoint == '/report/sample_finish':
+                response = self._handle_sample_finish_report(request_data)
+            elif endpoint == '/report/order_finish':
+                response = self._handle_order_finish_report(request_data)
+            elif endpoint == '/report/batch_update':
+                response = self._handle_batch_update_report(request_data)
+            # 扩展报送端点
+            elif endpoint == '/report/material_change':
+                response = self._handle_material_change_report(request_data)
+            elif endpoint == '/report/error_handling':
+                response = self._handle_error_handling_report(request_data)
+            # 保留LIMS协议端点以兼容现有系统
+            elif endpoint == '/LIMS/step_finish':
+                response = self._handle_step_finish_report(request_data)
+            elif endpoint == '/LIMS/preintake_finish':
+                response = self._handle_sample_finish_report(request_data)
+            elif endpoint == '/LIMS/order_finish':
+                response = self._handle_order_finish_report(request_data)
+            else:
+                response = HttpResponse(
+                    success=False,
+                    message=f"不支持的报送端点: {endpoint}",
+                    data={"supported_endpoints": [
+                        "/report/step_finish", 
+                        "/report/sample_finish", 
+                        "/report/order_finish",
+                        "/report/batch_update",
+                        "/report/material_change",
+                        "/report/error_handling"
+                    ]}
+                )
+            
+            # 发送响应
+            self._send_response(response)
+            
+        except Exception as e:
+            logger.error(f"处理工作站报送失败: {e}\\n{traceback.format_exc()}")
+            error_response = HttpResponse(
+                success=False,
+                message=f"请求处理失败: {str(e)}"
+            )
+            self._send_response(error_response)
+    
+    def do_GET(self):
+        """处理GET请求 - 健康检查和状态查询"""
+        try:
+            parsed_path = urlparse(self.path)
+            endpoint = parsed_path.path
+            
+            if endpoint == '/status':
+                response = self._handle_status_check()
+            elif endpoint == '/health':
+                response = HttpResponse(success=True, message="服务健康")
+            else:
+                response = HttpResponse(
+                    success=False,
+                    message=f"不支持的查询端点: {endpoint}",
+                    data={"supported_endpoints": ["/status", "/health"]}
+                )
+            
+            self._send_response(response)
+            
+        except Exception as e:
+            logger.error(f"GET请求处理失败: {e}")
+            error_response = HttpResponse(
+                success=False,
+                message=f"GET请求处理失败: {str(e)}"
+            )
+            self._send_response(error_response)
+    
+    def _handle_step_finish_report(self, request_data: Dict[str, Any]) -> HttpResponse:
+        """处理步骤完成报送（统一LIMS协议规范）"""
+        try:
+            # 验证基本字段
+            required_fields = ['token', 'request_time', 'data']
+            if missing_fields := [field for field in required_fields if field not in request_data]:
+                return HttpResponse(
+                    success=False,
+                    message=f"缺少必要字段: {', '.join(missing_fields)}"
+                )
+            
+            # 验证data字段内容
+            data = request_data['data']
+            data_required_fields = ['orderCode', 'orderName', 'stepName', 'stepId', 'sampleId', 'startTime', 'endTime']
+            if data_missing_fields := [field for field in data_required_fields if field not in data]:
+                return HttpResponse(
+                    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:
+            # 验证基本字段
+            required_fields = ['token', 'request_time', 'data']
+            if missing_fields := [field for field in required_fields if field not in request_data]:
+                return HttpResponse(
+                    success=False,
+                    message=f"缺少必要字段: {', '.join(missing_fields)}"
+                )
+            
+            # 验证data字段内容
+            data = request_data['data']
+            data_required_fields = ['orderCode', 'orderName', 'sampleId', 'startTime', 'endTime', 'Status']
+            if data_missing_fields := [field for field in data_required_fields if field not in data]:
+                return HttpResponse(
+                    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": "开始", 
+                "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:
+            # 验证基本字段
+            required_fields = ['token', 'request_time', 'data']
+            if missing_fields := [field for field in required_fields if field not in request_data]:
+                return HttpResponse(
+                    success=False,
+                    message=f"缺少必要字段: {', '.join(missing_fields)}"
+                )
+            
+            # 验证data字段内容
+            data = request_data['data']
+            data_required_fields = ['orderCode', 'orderName', 'startTime', 'endTime', 'status']
+            if data_missing_fields := [field for field in data_required_fields if field not in data]:
+                return HttpResponse(
+                    success=False,
+                    message=f"data字段缺少必要内容: {', '.join(data_missing_fields)}"
+                )
+            
+            # 处理物料使用记录
+            used_materials = []
+            if 'usedMaterials' in data:
+                for material_data in data['usedMaterials']:
+                    material = MaterialUsage(
+                        materialId=material_data.get('materialId', ''),
+                        locationId=material_data.get('locationId', ''),
+                        typeMode=material_data.get('typeMode', ''),
+                        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_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': [],
+                'order_results': [],
+                'total_processed': 0,
+                'total_failed': 0
+            }
+            
+            # 处理批量步骤更新
+            for step_data in step_updates:
+                try:
+                    step_data['token'] = request_data.get('token', step_data.get('token'))
+                    step_data['request_time'] = request_data.get('request_time', step_data.get('request_time'))
+                    result = self._handle_step_finish_report(step_data)
+                    results['step_results'].append(result)
+                    if result.success:
+                        results['total_processed'] += 1
+                    else:
+                        results['total_failed'] += 1
+                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:
+                    sample_data['token'] = request_data.get('token', sample_data.get('token'))
+                    sample_data['request_time'] = request_data.get('request_time', sample_data.get('request_time'))
+                    result = self._handle_sample_finish_report(sample_data)
+                    results['sample_results'].append(result)
+                    if result.success:
+                        results['total_processed'] += 1
+                    else:
+                        results['total_failed'] += 1
+                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:
+                    order_data['token'] = request_data.get('token', order_data.get('token'))
+                    order_data['request_time'] = request_data.get('request_time', order_data.get('request_time'))
+                    result = self._handle_order_finish_report(order_data)
+                    results['order_results'].append(result)
+                    if result.success:
+                        results['total_processed'] += 1
+                    else:
+                        results['total_failed'] += 1
+                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:
+            # 验证必需字段
+            required_fields = ['workstation_id', 'timestamp', 'resource_id', 'change_type']
+            if missing_fields := [field for field in required_fields if field not in request_data]:
+                return HttpResponse(
+                    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:
+            # 验证必需字段
+            required_fields = ['workstation_id', 'timestamp', 'error_type', 'error_message']
+            if missing_fields := [field for field in required_fields if field not in request_data]:
+                return HttpResponse(
+                    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:
+            return HttpResponse(
+                success=True,
+                message="工作站报送服务正常运行",
+                data={
+                    "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/order_finish",
+                        "POST /report/batch_update",
+                        "POST /report/material_change",
+                        "POST /report/error_handling",
+                        "GET /status",
+                        "GET /health"
+                    ]
+                }
+            )
+        except Exception as e:
+            logger.error(f"处理状态查询失败: {e}")
+            return HttpResponse(
+                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}")
+
+
+class WorkstationHTTPService:
+    """工作站HTTP服务"""
+    
+    def __init__(self, workstation_instance, host: str = "127.0.0.1", port: int = 8080):
+        self.workstation = workstation_instance
+        self.host = host
+        self.port = port
+        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)
+            
+            # 在单独线程中运行服务器
+            self.server_thread = threading.Thread(
+                target=self._run_server,
+                daemon=True,
+                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    # 步骤完成报送")
+            logger.info("  - POST /report/sample_finish  # 通量完成报送")
+            logger.info("  - POST /report/order_finish   # 任务完成报送")
+            logger.info("  - POST /report/batch_update   # 批量更新报送")
+            logger.info("扩展报送端点:")
+            logger.info("  - POST /report/material_change # 物料变更报送")
+            logger.info("  - POST /report/error_handling  # 错误处理报送")
+            logger.info("兼容端点:")
+            logger.info("  - POST /LIMS/step_finish      # 兼容LIMS步骤完成")
+            logger.info("  - POST /LIMS/preintake_finish # 兼容LIMS通量完成")
+            logger.info("  - POST /LIMS/order_finish     # 兼容LIMS任务完成")
+            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:
+                self.running = False
+                self.server.shutdown()
+                self.server.server_close()
+                
+                if self.server_thread and self.server_thread.is_alive():
+                    self.server_thread.join(timeout=5.0)
+                
+                logger.info("工作站HTTP报送服务已停止")
+                
+        except Exception as e:
+            logger.error(f"停止HTTP服务失败: {e}")
+    
+    def _run_server(self):
+        """运行HTTP服务器"""
+        try:
+            while self.running:
+                self.server.handle_request()
+        except Exception as e:
+            if self.running:  # 只在非正常停止时记录错误
+                logger.error(f"HTTP服务运行错误: {e}")
+    
+    @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"""
+        return f"http://{self.host}:{self.port}"
+
+
+# 导出主要类 - 保持向后兼容
+@dataclass
+class MaterialChangeReport:
+    """已废弃：物料变更报送，请使用统一的WorkstationReportRequest"""
+    pass
+
+
+@dataclass 
+class TaskExecutionReport:
+    """已废弃：任务执行报送，请使用统一的WorkstationReportRequest"""
+    pass
+
+
+# 导出列表
+__all__ = [
+    'WorkstationReportRequest',
+    'MaterialUsage',
+    'HttpResponse',
+    'WorkstationHTTPService',
+    # 向后兼容
+    'MaterialChangeReport',
+    'TaskExecutionReport'
+]

unilabos/devices/workstation/workstation_material_management.py

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

unilabos/devices/zhida_gcms/Zhida_GCMS_ROS2_User_Guide.md

@@ -0,0 +1,148 @@
+# 智达GCMS ROS2使用指南 / Zhida GCMS ROS2 User Guide
+
+## 概述 / Overview
+
+智达GCMS设备支持通过ROS2动作进行操作，包括CSV文件分析启动、设备状态查询等功能。
+
+The Zhida GCMS device supports operations through ROS2 actions, including CSV file analysis startup, device status queries, and other functions.
+
+## 主要功能 / Main Features
+
+### 1. CSV文件分析启动 / CSV File Analysis Startup (`start_with_csv_file`)
+
+- **功能 / Function**: 接收CSV文件路径，自动读取文件内容并启动分析 / Receives CSV file path, automatically reads file content and starts analysis
+- **输入 / Input**: CSV文件的绝对路径 / Absolute path of CSV file
+- **输出 / Output**: `{"return_info": str, "success": bool}`
+
+### 2. 设备状态查询 / Device Status Query (`get_status`)
+
+- **功能 / Function**: 获取设备当前运行状态 / Get current device running status
+- **输出 / Output**: 设备状态字符串（如"RunSample"、"Idle"等）/ Device status string (e.g., "RunSample", "Idle", etc.)
+
+### 3. 方法列表查询 / Method List Query (`get_methods`)
+
+- **功能 / Function**: 获取设备支持的所有方法列表 / Get all method lists supported by the device
+- **输出 / Output**: 方法列表字典 / Method list dictionary
+
+### 4. 放盘操作 / Tray Operation (`put_tray`)
+
+- **功能 / Function**: 控制设备准备样品托盘 / Control device to prepare sample tray
+- **输出 / Output**: 操作结果信息 / Operation result information
+
+### 5. 停止运行 / Stop Operation (`abort`)
+
+- **功能 / Function**: 中止当前正在进行的分析任务 / Abort current analysis task in progress
+- **输出 / Output**: 操作结果信息 / Operation result information
+
+### 6. 获取版本信息 / Get Version Information (`get_version`)
+
+- **功能 / Function**: 查询设备接口版本和固件版本信息 / Query device interface version and firmware version information
+- **输出 / Output**: 版本信息字典 / Version information dictionary
+
+## 使用方法 / Usage Methods
+
+### ROS2命令行使用 / ROS2 Command Line Usage
+
+### 1. 查询设备状态 / Query Device Status
+
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/get_status unilabos_msgs/action/EmptyIn "{}"
+```
+
+### 2. 查询方法列表 / Query Method List
+
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/get_methods unilabos_msgs/action/EmptyIn "{}"
+```
+
+### 3. 启动分析 / Start Analysis
+
+使用CSV文件启动分析 / Start analysis using CSV file:
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/start_with_csv_file unilabos_msgs/action/StrSingleInput "{string: 'D:/path/to/your/samples.csv'}"
+```
+
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/start_with_csv_file unilabos_msgs/action/StrSingleInput "{string: 'd:/UniLab/Uni-Lab-OS/unilabos/devices/zhida_gcms/zhida_gcms-test_3.csv'}"
+
+使用Base64编码数据启动分析 / Start analysis using Base64 encoded data:
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/start unilabos_msgs/action/StrSingleInput "{string: 'U2FtcGxlTmFtZSxBY3FNZXRob2QsUmFja0NvZGUsVmlhbFBvcyxTbXBsSW5qVm9sLE91dHB1dEZpbGU...'}"
+```
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/start unilabos_msgs/action/StrSingleInput "{string: 'U2FtcGxlTmFtZSxBY3FNZXRob2QsUmFja0NvZGUsVmlhbFBvcyxTbXBsSW5qVm9sLE91dHB1dEZpbGUKU2FtcGxlMDAxLDIwMjUwNjA0LXRlc3QsUmFjayAxLDEsMSwvQ2hyb21lbGVvbkxvY2FsL++/veixuO+/vcSyxLzvv73vv73vv73vv73vv73vv73vv73vv73vv70vMjAyNTA2MDQK'}"
+
+### 4. 放盘操作 / Tray Operation
+
+**注意 / Note**: 放盘操作是特殊场景下使用的功能，比如机械臂比较短需要让开位置，或者盘支架是可移动的时候，这个指令让进样器也去做相应动作。在当前配置中，空间足够，不需要这个额外的控制组件。
+
+**Note**: The tray operation is used in special scenarios, such as when the robotic arm is relatively short and needs to make room, or when the tray bracket is movable, this command makes the injector perform corresponding actions. In the current configuration, the space is sufficient and this additional control component is not needed.
+
+准备样品托盘 / Prepare sample tray:
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/put_tray unilabos_msgs/action/EmptyIn "{}"
+```
+
+### 5. 停止运行 / Stop Operation
+
+中止当前分析任务（注意！运行中发现任务运行中止，需要人工在InLab Solution 二次点击确认）/ Abort current analysis task (Note! If task abortion is detected during operation, manual confirmation is required by clicking twice in InLab Solution):
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/abort unilabos_msgs/action/EmptyIn "{}"
+```
+
+### 6. 获取版本信息 / Get Version Information
+
+查询设备版本 / Query device version:
+```bash
+ros2 action send_goal /devices/ZHIDA_GCMS_STATION/get_version unilabos_msgs/action/EmptyIn "{}"
+```
+
+### Python代码使用 / Python Code Usage
+
+```python
+from unilabos.devices.zhida_gcms.zhida import ZhidaClient
+
+# 初始化客户端 / Initialize client
+client = ZhidaClient(host='192.168.3.184', port=5792)
+client.connect()
+
+# 使用CSV文件启动分析 / Start analysis using CSV file
+result = client.start_with_csv_file('/path/to/your/file.csv')
+print(f"成功 / Success: {result['success']}")
+print(f"信息 / Info: {result['return_info']}")
+
+# 查询设备状态 / Query device status
+status = client.get_status()
+print(f"设备状态 / Device Status: {status}")
+
+client.close()
+```
+
+## 使用注意事项 / Usage Notes
+
+1. **文件路径 / File Path**: 必须使用绝对路径 / Must use absolute path
+2. **文件格式 / File Format**: CSV文件必须是UTF-8编码 / CSV file must be UTF-8 encoded
+3. **设备连接 / Device Connection**: 确保智达GCMS设备已连接并可访问 / Ensure Zhida GCMS device is connected and accessible
+4. **权限 / Permissions**: 确保有读取CSV文件的权限 / Ensure you have permission to read CSV files
+
+## 故障排除 / Troubleshooting
+
+### 常见问题 / Common Issues
+
+1. **文件路径错误 / File Path Error**: 确保使用绝对路径且文件存在 / Ensure using absolute path and file exists
+2. **编码问题 / Encoding Issue**: 确保CSV文件是UTF-8编码 / Ensure CSV file is UTF-8 encoded
+3. **设备连接 / Device Connection**: 检查网络连接和设备状态 / Check network connection and device status
+4. **权限问题 / Permission Issue**: 确保有文件读取权限 / Ensure you have file read permissions
+
+### 设备状态说明 / Device Status Description
+
+- `"Idle"`: 设备空闲状态 / Device idle status
+- `"RunSample"`: 正在运行样品分析 / Running sample analysis
+- `"Error"`: 设备错误状态 / Device error status
+
+## 总结 / Summary
+
+智达GCMS设备现在支持 / Zhida GCMS device now supports:
+
+1. 直接通过ROS2命令输入CSV文件路径启动分析 / Direct CSV file path input via ROS2 commands to start analysis
+2. 按需查询设备状态和方法列表 / On-demand device status and method list queries
+3. 完善的错误处理和日志记录 / Comprehensive error handling and logging
+4. 简化的操作流程 / Simplified operation workflow

unilabos/devices/zhida_gcms/device_test.json

@@ -0,0 +1,24 @@
+{
+    "nodes": [
+        {
+            "id": "ZHIDA_GCMS_STATION",
+            "name": "ZHIDA_GCMS",
+            "parent": null,
+            "type": "device",
+            "class": "zhida_gcms",
+            "position": {
+                "x": 620.6111111111111,
+                "y": 171,
+                "z": 0
+            },
+            "config": {
+                "host": "192.168.3.184",
+                "port": 5792,
+                "timeout": 10.0
+            },
+            "data": {},
+            "children": []
+        }
+    ],
+    "links": []
+}

unilabos/devices/zhida_gcms/zhida.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+智达GCMS设备驱动
+
+支持智达GCMS设备的TCP通信协议，包括状态查询、方法获取、样品分析等功能。
+通信协议版本：1.0.1
+"""
+
+import base64
+import json
+import socket
+import time
+import os
+from pathlib import Path
+
+
+class ZhidaClient:
+    def __init__(self, host='192.168.3.184', port=5792, timeout=10.0):
+        # 如果部署在智达GCMS上位机本地，可使用localhost: host='127.0.0.1'
+        """
+        初始化智达GCMS客户端
+        
+        Args:
+            host (str): 设备IP地址，本地部署时可使用'127.0.0.1'
+            port (int): 通信端口，默认5792
+            timeout (float): 超时时间，单位秒
+        """
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.sock = None
+        self._ros_node = None  # ROS节点引用，由框架设置
+    
+    def post_init(self, ros_node):
+        """
+        ROS节点初始化后的回调方法，用于建立设备连接
+        
+        Args:
+            ros_node: ROS节点实例
+        """
+        self._ros_node = ros_node
+        try:
+            self.connect()
+            ros_node.lab_logger().info(f"智达GCMS设备连接成功: {self.host}:{self.port}")
+        except Exception as e:
+            ros_node.lab_logger().error(f"智达GCMS设备连接失败: {e}")
+            # 不抛出异常，允许节点继续运行，后续可以重试连接
+
+    def connect(self):
+        """
+        建立TCP连接到智达GCMS设备
+        
+        Raises:
+            ConnectionError: 连接失败时抛出
+        """
+        try:
+            self.sock = socket.create_connection((self.host, self.port), timeout=self.timeout)
+            # 确保后续 recv/send 都会在 timeout 秒后抛 socket.timeout
+            self.sock.settimeout(self.timeout)
+        except Exception as e:
+            raise ConnectionError(f"Failed to connect to {self.host}:{self.port} - {str(e)}")
+
+    def close(self):
+        """
+        关闭与智达GCMS设备的TCP连接
+        """
+        if self.sock:
+            try:
+                self.sock.close()
+            except Exception:
+                pass  # 忽略关闭时的错误
+            finally:
+                self.sock = None
+
+    def _send_command(self, cmd: dict) -> dict:
+        """
+        发送命令到智达GCMS设备并接收响应
+        
+        Args:
+            cmd (dict): 要发送的命令字典
+            
+        Returns:
+            dict: 设备响应的JSON数据
+            
+        Raises:
+            ConnectionError: 连接错误
+            TimeoutError: 超时错误
+        """
+        if not self.sock:
+            raise ConnectionError("Not connected to device")
+
+        try:
+            # 发送JSON命令（UTF-8编码）
+            payload = json.dumps(cmd, ensure_ascii=False).encode('utf-8')
+            self.sock.sendall(payload)
+
+            # 循环接收数据直到能成功解析完整JSON
+            buffer = bytearray()
+            start = time.time()
+            while True:
+                try:
+                    chunk = self.sock.recv(4096)
+                    if not chunk:
+                        # 对端关闭连接，尝试解析已接收的数据
+                        if buffer:
+                            try:
+                                text = buffer.decode('utf-8', errors='strict')
+                                return json.loads(text)
+                            except (UnicodeDecodeError, json.JSONDecodeError):
+                                pass
+                        break
+                    buffer.extend(chunk)
+                    
+                    # 尝试解码和解析JSON
+                    text = buffer.decode('utf-8', errors='strict')
+                    try:
+                        return json.loads(text)
+                    except json.JSONDecodeError:
+                        # JSON不完整，继续接收
+                        pass
+                        
+                except socket.timeout:
+                    # 超时时，尝试解析已接收的数据
+                    if buffer:
+                        try:
+                            text = buffer.decode('utf-8', errors='strict')
+                            return json.loads(text)
+                        except (UnicodeDecodeError, json.JSONDecodeError):
+                            pass
+                    raise TimeoutError(f"recv() timed out after {self.timeout:.1f}s")
+                
+                # 防止死循环，总时长超过2倍超时时间就报错
+                if time.time() - start > self.timeout * 2:
+                    # 最后尝试解析已接收的数据
+                    if buffer:
+                        try:
+                            text = buffer.decode('utf-8', errors='strict')
+                            return json.loads(text)
+                        except (UnicodeDecodeError, json.JSONDecodeError):
+                            pass
+                    raise TimeoutError(f"No complete JSON received after {time.time() - start:.1f}s")
+
+            # 连接关闭，如果有数据则尝试解析
+            if buffer:
+                try:
+                    text = buffer.decode('utf-8', errors='strict')
+                    return json.loads(text)
+                except (UnicodeDecodeError, json.JSONDecodeError):
+                    pass
+            
+            raise ConnectionError("Connection closed before JSON could be parsed")
+            
+        except Exception as e:
+            if isinstance(e, (ConnectionError, TimeoutError)):
+                raise
+            else:
+                raise ConnectionError(f"Command send failed: {str(e)}")
+
+    def get_status(self) -> str:
+        """
+        获取设备状态
+        
+        Returns:
+            str: 设备状态 (Idle|Offline|Error|Busy|RunSample|Unknown)
+        """
+        if not self.sock:
+            # 尝试重新连接
+            try:
+                self.connect()
+                if self._ros_node:
+                    self._ros_node.lab_logger().info("智达GCMS设备重新连接成功")
+            except Exception as e:
+                if self._ros_node:
+                    self._ros_node.lab_logger().warning(f"智达GCMS设备连接失败: {e}")
+                return "Offline"
+        
+        try:
+            response = self._send_command({"command": "getstatus"})
+            return response.get("result", "Unknown")
+        except Exception as e:
+            if self._ros_node:
+                self._ros_node.lab_logger().warning(f"获取设备状态失败: {e}")
+            return "Error"
+    
+    def get_methods(self) -> dict:
+        """
+        获取当前Project的方法列表
+        
+        Returns:
+            dict: 包含方法列表的响应
+        """
+        if not self.sock:
+            try:
+                self.connect()
+                if self._ros_node:
+                    self._ros_node.lab_logger().info("智达GCMS设备重新连接成功")
+            except Exception as e:
+                if self._ros_node:
+                    self._ros_node.lab_logger().warning(f"智达GCMS设备连接失败: {e}")
+                return {"error": "Device not connected"}
+        
+        try:
+            return self._send_command({"command": "getmethods"})
+        except Exception as e:
+            if self._ros_node:
+                self._ros_node.lab_logger().warning(f"获取方法列表失败: {e}")
+            return {"error": str(e)}
+
+
+    
+    def get_version(self) -> dict:
+        """
+        获取接口版本和InLabPAL固件版本
+        
+        Returns:
+            dict: 响应格式 {"result": "OK|Error", "message": "Interface:x.x.x;FW:x.x.x.xxx"}
+        """
+        return self._send_command({"command": "version"})
+    
+    def put_tray(self) -> dict:
+        """
+        放盘操作，准备InLabPAL进样器
+        
+        注意：此功能仅在特殊场景下使用，例如：
+        - 机械臂比较短，需要让开一个位置
+        - 盘支架是可移动的，需要进样器配合做动作
+        
+        对于宜宾深势这套配置，空间足够，不需要这个额外的控制组件。
+        
+        Returns:
+            dict: 响应格式 {"result": "OK|Error", "message": "ready_info|error_info"}
+        """
+        return self._send_command({"command": "puttray"})
+
+    def start_with_csv_file(self, string: str = None, csv_file_path: str = None) -> dict:
+        """
+        使用CSV文件启动分析（支持ROS2动作调用）
+        
+        Args:
+            string (str): CSV文件路径（ROS2参数名）
+            csv_file_path (str): CSV文件路径（兼容旧接口）
+            
+        Returns:
+            dict: ROS2动作结果格式 {"return_info": str, "success": bool}
+            
+        Raises:
+            FileNotFoundError: CSV文件不存在
+            Exception: 文件读取或通信错误
+        """
+        try:
+            # 支持两种参数传递方式：ROS2的string参数和直接的csv_file_path参数
+            file_path = string if string is not None else csv_file_path
+            if file_path is None:
+                error_msg = "未提供CSV文件路径参数"
+                if self._ros_node:
+                    self._ros_node.lab_logger().error(error_msg)
+                return {"return_info": error_msg, "success": False}
+            
+            # 使用Path对象进行更健壮的文件处理
+            csv_path = Path(file_path)
+            if not csv_path.exists():
+                error_msg = f"CSV文件不存在: {file_path}"
+                if self._ros_node:
+                    self._ros_node.lab_logger().error(error_msg)
+                return {"return_info": error_msg, "success": False}
+            
+            # 读取CSV文件内容（UTF-8编码，替换未知字符）
+            csv_content = csv_path.read_text(encoding="utf-8", errors="replace")
+            
+            # 转换为Base64编码
+            b64_content = base64.b64encode(csv_content.encode('utf-8')).decode('ascii')
+            
+            if self._ros_node:
+                self._ros_node.lab_logger().info(f"正在发送CSV文件到智达GCMS: {file_path}")
+                self._ros_node.lab_logger().info(f"Base64编码长度: {len(b64_content)} 字符")
+            
+            # 发送start命令
+            response = self._send_command({
+                "command": "start",
+                "message": b64_content
+            })
+            
+            # 转换为ROS2动作结果格式
+            if response.get("result") == "OK":
+                success_msg = f"智达GCMS分析启动成功: {response.get('message', 'Unknown')}"
+                if self._ros_node:
+                    self._ros_node.lab_logger().info(success_msg)
+                return {"return_info": success_msg, "success": True}
+            else:
+                error_msg = f"智达GCMS分析启动失败: {response.get('message', 'Unknown error')}"
+                if self._ros_node:
+                    self._ros_node.lab_logger().error(error_msg)
+                return {"return_info": error_msg, "success": False}
+            
+        except Exception as e:
+            error_msg = f"CSV文件处理失败: {str(e)}"
+            if self._ros_node:
+                self._ros_node.lab_logger().error(error_msg)
+            return {"return_info": error_msg, "success": False}
+
+    def start(self, string: str = None, text: str = None) -> dict:
+        """
+        使用Base64编码数据启动分析（支持ROS2动作调用）
+        
+        Args:
+            string (str): Base64编码的CSV数据（ROS2参数名）
+            text (str): Base64编码的CSV数据（兼容旧接口）
+            
+        Returns:
+            dict: ROS2动作结果格式 {"return_info": str, "success": bool}
+        """
+        try:
+            # 支持两种参数传递方式：ROS2的string参数和原有的text参数
+            b64_content = string if string is not None else text
+            if b64_content is None:
+                error_msg = "未提供Base64编码数据参数"
+                if self._ros_node:
+                    self._ros_node.lab_logger().error(error_msg)
+                return {"return_info": error_msg, "success": False}
+            
+            if self._ros_node:
+                self._ros_node.lab_logger().info(f"正在发送Base64数据到智达GCMS")
+                self._ros_node.lab_logger().info(f"Base64编码长度: {len(b64_content)} 字符")
+            
+            # 发送start命令
+            response = self._send_command({
+                "command": "start",
+                "message": b64_content
+            })
+            
+            # 转换为ROS2动作结果格式
+            if response.get("result") == "OK":
+                success_msg = f"智达GCMS分析启动成功: {response.get('message', 'Unknown')}"
+                if self._ros_node:
+                    self._ros_node.lab_logger().info(success_msg)
+                return {"return_info": success_msg, "success": True}
+            else:
+                error_msg = f"智达GCMS分析启动失败: {response.get('message', 'Unknown error')}"
+                if self._ros_node:
+                    self._ros_node.lab_logger().error(error_msg)
+                return {"return_info": error_msg, "success": False}
+            
+        except Exception as e:
+            error_msg = f"Base64数据处理失败: {str(e)}"
+            if self._ros_node:
+                self._ros_node.lab_logger().error(error_msg)
+            return {"return_info": error_msg, "success": False}
+
+    def abort(self) -> dict:
+        """
+        停止当前运行的分析
+        
+        Returns:
+            dict: 响应格式 {"result": "OK|Error", "message": "error_info"}
+        """
+        return self._send_command({"command": "abort"})
+
+
+def test_zhida_client():
+    """
+    测试智达GCMS客户端功能
+    """
+    client = ZhidaClient()
+    
+    try:
+        # 连接设备
+        print("Connecting to Zhida GCMS...")
+        client.connect()
+        print("Connected successfully!")
+        
+        # 获取设备状态
+        print(f"Device status: {client.status}")
+        
+        # 获取版本信息
+        version_info = client.get_version()
+        print(f"Version info: {version_info}")
+        
+        # 获取方法列表
+        methods = client.get_methods()
+        print(f"Available methods: {methods}")
+        
+        # 测试CSV文件发送（如果文件存在）
+        csv_file = Path(__file__).parent / "zhida_gcms-test_1.csv"
+        if csv_file.exists():
+            print(f"Testing CSV file: {csv_file}")
+            result = client.start_with_csv_file(str(csv_file))
+            print(f"Start result: {result}")
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+    
+    finally:
+        # 关闭连接
+        client.close()
+        print("Connection closed.")
+
+
+if __name__ == "__main__":
+    test_zhida_client()

unilabos/devices/zhida_gcms/zhida_gcms-test_1.csv

@@ -0,0 +1,2 @@
+SampleName,AcqMethod,RackCode,VialPos,SmplInjVol,OutputFile
+Sample001,/ChromeleonLocal/<2F>豸<EFBFBD>IJļ<C4B2><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/20250604/20231113.seq/20250604-test,Rack 1,1,1,/ChromeleonLocal/<2F>豸<EFBFBD>IJļ<C4B2><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/20250604

unilabos/registry/devices/balance.yaml

@@ -0,0 +1 @@
+{}

unilabos/registry/devices/bioyond_workstation.yaml

@@ -0,0 +1,812 @@
+bioyondworkstation_device:
+  category:
+  - bioyond_workstation
+  class:
+    action_value_mappings:
+      auto-Bioystation_1_to_2_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_1_to_2_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_3_to_2_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_3_to_2_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_feeding4to3_from_xlsx_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_feeding4to3_from_xlsx_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_scheduler_continue_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_scheduler_continue_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_scheduler_start_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_scheduler_start_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_scheduler_stop_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_scheduler_stop_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-Bioystation_start_experiment_task:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: Bioystation_start_experiment_task参数
+          type: object
+        type: UniLabJsonCommand
+      auto-auto_batch_outbound_from_xlsx:
+        feedback: {}
+        goal: {}
+        goal_default:
+          xlsx_path: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                xlsx_path:
+                  type: string
+              required:
+              - xlsx_path
+              type: object
+            result: {}
+          required:
+          - goal
+          title: auto_batch_outbound_from_xlsx参数
+          type: object
+        type: UniLabJsonCommand
+      auto-auto_feeding4to3_from_xlsx:
+        feedback: {}
+        goal: {}
+        goal_default:
+          xlsx_path: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                xlsx_path:
+                  type: string
+              required:
+              - xlsx_path
+              type: object
+            result: {}
+          required:
+          - goal
+          title: auto_feeding4to3_from_xlsx参数
+          type: object
+        type: UniLabJsonCommand
+      auto-create_orders:
+        feedback: {}
+        goal: {}
+        goal_default:
+          xlsx_path: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                xlsx_path:
+                  type: string
+              required:
+              - xlsx_path
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_orders参数
+          type: object
+        type: UniLabJsonCommand
+      auto-order_list:
+        feedback: {}
+        goal: {}
+        goal_default:
+          begin_time: null
+          end_time: null
+          filter_text: null
+          page: 10
+          skip: 0
+          status: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                begin_time:
+                  type: string
+                end_time:
+                  type: string
+                filter_text:
+                  type: string
+                page:
+                  default: 10
+                  type: integer
+                skip:
+                  default: 0
+                  type: integer
+                status:
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: order_list参数
+          type: object
+        type: UniLabJsonCommand
+      auto-order_list_v2:
+        feedback: {}
+        goal: {}
+        goal_default:
+          beginTime: ''
+          endTime: ''
+          filter: ''
+          pageCount: 1
+          skipCount: 0
+          sorting: ''
+          status: ''
+          timeType: string
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                beginTime:
+                  default: ''
+                  type: string
+                endTime:
+                  default: ''
+                  type: string
+                filter:
+                  default: ''
+                  type: string
+                pageCount:
+                  default: 1
+                  type: integer
+                skipCount:
+                  default: 0
+                  type: integer
+                sorting:
+                  default: ''
+                  type: string
+                status:
+                  default: ''
+                  type: string
+                timeType:
+                  default: string
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: order_list_v2参数
+          type: object
+        type: UniLabJsonCommand
+      auto-order_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          order_id: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                order_id:
+                  type: string
+              required:
+              - order_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: order_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-report_material_change:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_obj: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_obj:
+                  type: object
+              required:
+              - material_obj
+              type: object
+            result: {}
+          required:
+          - goal
+          title: report_material_change参数
+          type: object
+        type: UniLabJsonCommand
+      auto-report_order_finish:
+        feedback: {}
+        goal: {}
+        goal_default:
+          completion_time: null
+          end_time: null
+          order_code: null
+          order_name: null
+          start_time: null
+          status: '30'
+          used_materials: null
+          workflow_status: Finished
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                completion_time:
+                  type: string
+                end_time:
+                  type: string
+                order_code:
+                  type: string
+                order_name:
+                  type: string
+                start_time:
+                  type: string
+                status:
+                  default: '30'
+                  type: string
+                used_materials:
+                  type: string
+                workflow_status:
+                  default: Finished
+                  type: string
+              required:
+              - order_code
+              - order_name
+              - start_time
+              - end_time
+              type: object
+            result: {}
+          required:
+          - goal
+          title: report_order_finish参数
+          type: object
+        type: UniLabJsonCommand
+      auto-report_step_finish:
+        feedback: {}
+        goal: {}
+        goal_default:
+          end_time: null
+          execution_status: completed
+          order_code: null
+          order_name: null
+          sample_id: null
+          start_time: null
+          step_id: null
+          step_name: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                end_time:
+                  type: string
+                execution_status:
+                  default: completed
+                  type: string
+                order_code:
+                  type: string
+                order_name:
+                  type: string
+                sample_id:
+                  type: string
+                start_time:
+                  type: string
+                step_id:
+                  type: string
+                step_name:
+                  type: string
+              required:
+              - order_code
+              - order_name
+              - step_name
+              - step_id
+              - sample_id
+              - start_time
+              - end_time
+              type: object
+            result: {}
+          required:
+          - goal
+          title: report_step_finish参数
+          type: object
+        type: UniLabJsonCommand
+      auto-run_full_workflow:
+        feedback: {}
+        goal: {}
+        goal_default:
+          inbound_items: null
+          orders: null
+          poll_filter_code: null
+          poll_interval_s: 5
+          poll_timeout_s: 600
+          takeout_order_id: null
+          transfer_source: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                inbound_items:
+                  items:
+                    type: object
+                  type: array
+                orders:
+                  items:
+                    type: object
+                  type: array
+                poll_filter_code:
+                  type: string
+                poll_interval_s:
+                  default: 5
+                  type: integer
+                poll_timeout_s:
+                  default: 600
+                  type: integer
+                takeout_order_id:
+                  type: string
+                transfer_source:
+                  type: string
+              required:
+              - inbound_items
+              - orders
+              type: object
+            result: {}
+          required:
+          - goal
+          title: run_full_workflow参数
+          type: object
+        type: UniLabJsonCommand
+      auto-scheduler_continue:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: scheduler_continue参数
+          type: object
+        type: UniLabJsonCommand
+      auto-scheduler_start:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: scheduler_start参数
+          type: object
+        type: UniLabJsonCommand
+      auto-scheduler_stop:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: scheduler_stop参数
+          type: object
+        type: UniLabJsonCommand
+      auto-start_station1_internal_flow:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: start_station1_internal_flow参数
+          type: object
+        type: UniLabJsonCommand
+      auto-storage_batch_inbound:
+        feedback: {}
+        goal: {}
+        goal_default:
+          items: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                items:
+                  items:
+                    type: object
+                  type: array
+              required:
+              - items
+              type: object
+            result: {}
+          required:
+          - goal
+          title: storage_batch_inbound参数
+          type: object
+        type: UniLabJsonCommand
+      auto-storage_inbound:
+        feedback: {}
+        goal: {}
+        goal_default:
+          location_id: null
+          material_id: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                location_id:
+                  type: string
+                material_id:
+                  type: string
+              required:
+              - material_id
+              - location_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: storage_inbound参数
+          type: object
+        type: UniLabJsonCommand
+      auto-take_out:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_ids: null
+          order_id: null
+          preintake_ids: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_ids:
+                  type: string
+                order_id:
+                  type: string
+                preintake_ids:
+                  type: string
+              required:
+              - order_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: take_out参数
+          type: object
+        type: UniLabJsonCommand
+      auto-test_benyao_workstation:
+        feedback: {}
+        goal: {}
+        goal_default:
+          num1: null
+          num2: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                num1:
+                  type: string
+                num2:
+                  type: string
+              required:
+              - num1
+              - num2
+              type: object
+            result: {}
+          required:
+          - goal
+          title: test_benyao_workstation参数
+          type: object
+        type: UniLabJsonCommand
+      auto-transfer_1_to_2:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_1_to_2参数
+          type: object
+        type: UniLabJsonCommand
+      auto-transfer_3_to_2_to_1:
+        feedback: {}
+        goal: {}
+        goal_default:
+          source_wh_id: 3a19debc-84b4-0359-e2d4-b3beea49348b
+          source_x: 1
+          source_y: 1
+          source_z: 1
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                source_wh_id:
+                  default: 3a19debc-84b4-0359-e2d4-b3beea49348b
+                  type: string
+                source_x:
+                  default: 1
+                  type: integer
+                source_y:
+                  default: 1
+                  type: integer
+                source_z:
+                  default: 1
+                  type: integer
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_3_to_2_to_1参数
+          type: object
+        type: UniLabJsonCommand
+      auto-wait_for_transfer_task:
+        feedback: {}
+        goal: {}
+        goal_default:
+          filter_text: null
+          interval: 5
+          timeout: 3000
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                filter_text:
+                  type: string
+                interval:
+                  default: 5
+                  type: integer
+                timeout:
+                  default: 3000
+                  type: integer
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: wait_for_transfer_task参数
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.devices.workstation.bioyond_cell.bioyond_workstation:BioyondWorkstation
+    status_types: {}
+    type: python
+  config_info: []
+  description: 宜宾配液分液工站
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        bioyond_config:
+          type: string
+        debug_mode:
+          default: false
+          type: boolean
+        station_resource:
+          type: string
+      required: []
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  registry_type: device
+  version: 1.0.0

unilabos/registry/devices/dispensing_station_bioyond.yaml

@@ -0,0 +1,506 @@
+dispensing_station.bioyond:
+  category:
+  - work_station
+  - dispensing_station_bioyond
+  class:
+    action_value_mappings:
+      bioyond_sync:
+        feedback: {}
+        goal:
+          force_sync: force_sync
+          sync_type: sync_type
+        goal_default:
+          force_sync: false
+          sync_type: full
+        handles: {}
+        result: {}
+        schema:
+          description: 从Bioyond系统同步物料
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                force_sync:
+                  description: 是否强制同步
+                  type: boolean
+                sync_type:
+                  description: 同步类型
+                  enum:
+                  - full
+                  - incremental
+                  type: string
+              required:
+              - sync_type
+              type: object
+            result: {}
+          required:
+          - goal
+          title: bioyond_sync参数
+          type: object
+        type: UniLabJsonCommand
+      bioyond_update:
+        feedback: {}
+        goal:
+          material_ids: material_ids
+          sync_all: sync_all
+        goal_default:
+          material_ids: []
+          sync_all: true
+        handles: {}
+        result: {}
+        schema:
+          description: 将本地物料变更同步到Bioyond
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_ids:
+                  description: 要同步的物料ID列表
+                  items:
+                    type: string
+                  type: array
+                sync_all:
+                  description: 是否同步所有物料
+                  type: boolean
+              required:
+              - sync_all
+              type: object
+            result: {}
+          required:
+          - goal
+          title: bioyond_update参数
+          type: object
+        type: UniLabJsonCommand
+      create_90_10_vial_feeding_task:
+        feedback: {}
+        goal:
+          delay_time: delay_time
+          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_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: '600'
+          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_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: '400'
+          temperature: '20'
+        handles: {}
+        result: {}
+        schema:
+          description: 创建90%/10%小瓶投料任务
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  default: '600'
+                  description: 延迟时间(s)
+                  type: string
+                order_name:
+                  description: 任务名称
+                  type: string
+                percent_10_1_assign_material_name:
+                  description: 10%组分1物料名称
+                  type: string
+                percent_10_1_liquid_material_name:
+                  description: 10%组分1液体物料名称
+                  type: string
+                percent_10_1_target_weigh:
+                  description: 10%组分1目标重量(g)
+                  type: string
+                percent_10_1_volume:
+                  description: 10%组分1液体体积(mL)
+                  type: string
+                percent_10_2_assign_material_name:
+                  description: 10%组分2物料名称
+                  type: string
+                percent_10_2_liquid_material_name:
+                  description: 10%组分2液体物料名称
+                  type: string
+                percent_10_2_target_weigh:
+                  description: 10%组分2目标重量(g)
+                  type: string
+                percent_10_2_volume:
+                  description: 10%组分2液体体积(mL)
+                  type: string
+                percent_90_1_assign_material_name:
+                  description: 90%组分1物料名称
+                  type: string
+                percent_90_1_target_weigh:
+                  description: 90%组分1目标重量(g)
+                  type: string
+                percent_90_2_assign_material_name:
+                  description: 90%组分2物料名称
+                  type: string
+                percent_90_2_target_weigh:
+                  description: 90%组分2目标重量(g)
+                  type: string
+                percent_90_3_assign_material_name:
+                  description: 90%组分3物料名称
+                  type: string
+                percent_90_3_target_weigh:
+                  description: 90%组分3目标重量(g)
+                  type: string
+                speed:
+                  default: '400'
+                  description: 搅拌速度(rpm)
+                  type: string
+                temperature:
+                  default: '20'
+                  description: 温度(°C)
+                  type: string
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_90_10_vial_feeding_task参数
+          type: object
+        type: UniLabJsonCommand
+      create_batch_90_10_vial_feeding_task:
+        feedback: {}
+        goal:
+          batch_data: batch_data
+        goal_default:
+          batch_data: '{}'
+        handles: {}
+        result: {}
+        schema:
+          description: 创建批量90%10%小瓶投料任务
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                batch_data:
+                  description: 批量90%10%小瓶投料任务数据(JSON格式)，包含batch_name、tasks列表和global_settings
+                  type: string
+              required:
+              - batch_data
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_batch_90_10_vial_feeding_task参数
+          type: object
+        type: UniLabJsonCommand
+      create_batch_diamine_solution_task:
+        feedback: {}
+        goal:
+          batch_data: batch_data
+        goal_default:
+          batch_data: '{}'
+        handles: {}
+        result: {}
+        schema:
+          description: 创建批量二胺溶液配制任务
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                batch_data:
+                  description: 批量二胺溶液配制任务数据(JSON格式)，包含batch_name、tasks列表和global_settings
+                  type: string
+              required:
+              - batch_data
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_batch_diamine_solution_task参数
+          type: object
+        type: UniLabJsonCommand
+      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: '600'
+          hold_m_name: ''
+          liquid_material_name: NMP
+          material_name: ''
+          order_name: ''
+          speed: '400'
+          target_weigh: ''
+          temperature: '20'
+          volume: ''
+        handles: {}
+        result: {}
+        schema:
+          description: 创建二胺溶液配制任务
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  default: '600'
+                  description: 延迟时间(s)
+                  type: string
+                hold_m_name:
+                  description: 库位名称(如ODA-1)
+                  type: string
+                liquid_material_name:
+                  default: NMP
+                  description: 液体物料名称
+                  type: string
+                material_name:
+                  description: 固体物料名称
+                  type: string
+                order_name:
+                  description: 任务名称
+                  type: string
+                speed:
+                  default: '400'
+                  description: 搅拌速度(rpm)
+                  type: string
+                target_weigh:
+                  description: 固体目标重量(g)
+                  type: string
+                temperature:
+                  default: '20'
+                  description: 温度(°C)
+                  type: string
+                volume:
+                  description: 液体体积(mL)
+                  type: string
+              required:
+              - material_name
+              - target_weigh
+              - volume
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_diamine_solution_task参数
+          type: object
+        type: UniLabJsonCommand
+      create_resource:
+        feedback: {}
+        goal:
+          resource_config: resource_config
+          resource_type: resource_type
+        goal_default:
+          resource_config: {}
+          resource_type: ''
+        handles: {}
+        result: {}
+        schema:
+          description: 创建资源操作
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                resource_config:
+                  description: 资源配置
+                  type: object
+                resource_type:
+                  description: 资源类型
+                  type: string
+              required:
+              - resource_type
+              - resource_config
+              type: object
+            result: {}
+          required:
+          - goal
+          title: create_resource参数
+          type: object
+        type: UniLabJsonCommand
+      dispensing_material_inbound:
+        feedback: {}
+        goal:
+          location: location
+          material_id: material_id
+        goal_default:
+          location: ''
+          material_id: ''
+        handles: {}
+        result: {}
+        schema:
+          description: 配液站物料入库操作
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                location:
+                  description: 存储位置
+                  type: string
+                material_id:
+                  description: 物料ID
+                  type: string
+              required:
+              - material_id
+              - location
+              type: object
+            result: {}
+          required:
+          - goal
+          title: dispensing_material_inbound参数
+          type: object
+        type: UniLabJsonCommand
+      dispensing_material_outbound:
+        feedback: {}
+        goal:
+          material_id: material_id
+          quantity: quantity
+        goal_default:
+          material_id: ''
+          quantity: 0.0
+        handles: {}
+        result: {}
+        schema:
+          description: 配液站物料出库操作
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_id:
+                  description: 物料ID
+                  type: string
+                quantity:
+                  description: 出库数量
+                  type: number
+              required:
+              - material_id
+              - quantity
+              type: object
+            result: {}
+          required:
+          - goal
+          title: dispensing_material_outbound参数
+          type: object
+        type: UniLabJsonCommand
+      sample_waste_removal:
+        feedback: {}
+        goal:
+          sample_id: sample_id
+          waste_type: waste_type
+        goal_default:
+          sample_id: ''
+          waste_type: general
+        handles: {}
+        result: {}
+        schema:
+          description: 样品废料移除操作
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                sample_id:
+                  description: 样品ID
+                  type: string
+                waste_type:
+                  description: 废料类型
+                  enum:
+                  - general
+                  - hazardous
+                  - organic
+                  - inorganic
+                  type: string
+              required:
+              - sample_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: sample_waste_removal参数
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.devices.workstation.bioyond_studio.station:BioyondWorkstation
+    protocol_type: []
+    status_types:
+      bioyond_status: dict
+      enable_dispensing_station: bool
+      enable_reaction_station: bool
+      station_type: str
+    type: python
+  config_info: []
+  description: Bioyond配液站 - 专门用于物料配制和管理的工作站
+  handles: []
+  icon: 配液站.webp
+  init_param_schema:
+    config:
+      properties:
+        bioyond_config:
+          description: Bioyond API配置
+          properties:
+            api_host:
+              description: Bioyond API主机地址
+              type: string
+            api_key:
+              description: Bioyond API密钥
+              type: string
+            material_type_mappings:
+              description: 物料类型映射配置
+              type: object
+            workflow_mappings:
+              description: 工作流映射配置
+              type: object
+          type: object
+        deck:
+          description: Deck配置
+          type: object
+        station_config:
+          description: 配液站配置
+          properties:
+            description:
+              description: 配液站描述
+              type: string
+            enable_dispensing_station:
+              default: true
+              description: 启用配液站功能
+              type: boolean
+            enable_reaction_station:
+              default: false
+              description: 禁用反应站功能
+              type: boolean
+            station_name:
+              description: 配液站名称
+              type: string
+            station_type:
+              default: dispensing_station
+              description: 站点类型 - 配液站
+              enum:
+              - dispensing_station
+              type: string
+          type: object
+      required: []
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  version: 1.0.0

unilabos/registry/devices/liquid_handler.yaml

@@ -355,7 +355,6 @@ liquid_handler:
         feedback: {}
         goal:
           blow_out_air_volume: blow_out_air_volume
-          end_delay: end_delay
           flow_rates: flow_rates
           liquid_height: liquid_height
           offsets: offsets
@@ -5833,7 +5832,6 @@ liquid_handler.prcxi:
         feedback: {}
         goal:
           blow_out_air_volume: blow_out_air_volume
-          end_delay: end_delay
           flow_rates: flow_rates
           liquid_height: liquid_height
           offsets: offsets
@@ -7306,151 +7304,6 @@ liquid_handler.prcxi:
           title: LiquidHandlerRemove
           type: object
         type: LiquidHandlerRemove
-      set_group:
-        feedback: {}
-        goal:
-          group_name: group_name
-          volumes: volumes
-          wells: wells
-        goal_default:
-          group_name: ''
-          volumes:
-          - 0.0
-          wells:
-          - category: ''
-            children: []
-            config: ''
-            data: ''
-            id: ''
-            name: ''
-            parent: ''
-            pose:
-              orientation:
-                w: 1.0
-                x: 0.0
-                y: 0.0
-                z: 0.0
-              position:
-                x: 0.0
-                y: 0.0
-                z: 0.0
-            sample_id: ''
-            type: ''
-        handles: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties: {}
-              required: []
-              title: LiquidHandlerSetGroup_Feedback
-              type: object
-            goal:
-              properties:
-                group_name:
-                  type: string
-                volumes:
-                  items:
-                    type: number
-                  type: array
-                wells:
-                  items:
-                    properties:
-                      category:
-                        type: string
-                      children:
-                        items:
-                          type: string
-                        type: array
-                      config:
-                        type: string
-                      data:
-                        type: string
-                      id:
-                        type: string
-                      name:
-                        type: string
-                      parent:
-                        type: string
-                      pose:
-                        properties:
-                          orientation:
-                            properties:
-                              w:
-                                type: number
-                              x:
-                                type: number
-                              y:
-                                type: number
-                              z:
-                                type: number
-                            required:
-                            - x
-                            - y
-                            - z
-                            - w
-                            title: orientation
-                            type: object
-                          position:
-                            properties:
-                              x:
-                                type: number
-                              y:
-                                type: number
-                              z:
-                                type: number
-                            required:
-                            - x
-                            - y
-                            - z
-                            title: position
-                            type: object
-                        required:
-                        - position
-                        - orientation
-                        title: pose
-                        type: object
-                      sample_id:
-                        type: string
-                      type:
-                        type: string
-                    required:
-                    - id
-                    - name
-                    - sample_id
-                    - children
-                    - parent
-                    - type
-                    - category
-                    - pose
-                    - config
-                    - data
-                    title: wells
-                    type: object
-                  type: array
-              required:
-              - group_name
-              - wells
-              - volumes
-              title: LiquidHandlerSetGroup_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: LiquidHandlerSetGroup_Result
-              type: object
-          required:
-          - goal
-          title: LiquidHandlerSetGroup
-          type: object
-        type: LiquidHandlerSetGroup
       set_liquid:
         feedback: {}
         goal:
@@ -7826,56 +7679,6 @@ liquid_handler.prcxi:
           title: Transfer
           type: object
         type: Transfer
-      transfer_group:
-        feedback: {}
-        goal:
-          source_group_name: source_group_name
-          target_group_name: target_group_name
-          unit_volume: unit_volume
-        goal_default:
-          source_group_name: ''
-          target_group_name: ''
-          unit_volume: 0.0
-        handles: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback:
-              properties: {}
-              required: []
-              title: LiquidHandlerTransferGroup_Feedback
-              type: object
-            goal:
-              properties:
-                source_group_name:
-                  type: string
-                target_group_name:
-                  type: string
-                unit_volume:
-                  type: number
-              required:
-              - source_group_name
-              - target_group_name
-              - unit_volume
-              title: LiquidHandlerTransferGroup_Goal
-              type: object
-            result:
-              properties:
-                return_info:
-                  type: string
-                success:
-                  type: boolean
-              required:
-              - return_info
-              - success
-              title: LiquidHandlerTransferGroup_Result
-              type: object
-          required:
-          - goal
-          title: LiquidHandlerTransferGroup
-          type: object
-        type: LiquidHandlerTransferGroup
       transfer_liquid:
         feedback: {}
         goal:
@@ -8377,6 +8180,9 @@ liquid_handler.prcxi:
           type: object
         host:
           type: string
+        is_9320:
+          default: false
+          type: string
         matrix_id:
           default: ''
           type: string

unilabos/registry/devices/neware_battery_test_system.yaml

@@ -0,0 +1,344 @@
+neware_battery_test_system:
+  category:
+  - neware_battery_test_system
+  class:
+    action_value_mappings:
+      auto-post_init:
+        feedback: {}
+        goal: {}
+        goal_default:
+          ros_node: null
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                ros_node:
+                  type: string
+              required:
+              - ros_node
+              type: object
+            result: {}
+          required:
+          - goal
+          title: post_init参数
+          type: object
+        type: UniLabJsonCommand
+      auto-print_status_summary:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: print_status_summary参数
+          type: object
+        type: UniLabJsonCommand
+      auto-test_connection:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: test_connection参数
+          type: object
+        type: UniLabJsonCommand
+      export_status_json:
+        feedback: {}
+        goal:
+          filepath: filepath
+        goal_default:
+          filepath: bts_status.json
+        handles: {}
+        result:
+          return_info: return_info
+          success: success
+        schema:
+          description: 导出当前状态数据到JSON文件
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                filepath:
+                  default: bts_status.json
+                  description: 输出JSON文件路径
+                  type: string
+              required: []
+              type: object
+            result:
+              properties:
+                return_info:
+                  description: 导出操作结果信息
+                  type: string
+                success:
+                  description: 导出是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              type: object
+          required:
+          - goal
+          type: object
+        type: UniLabJsonCommand
+      get_device_summary:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result:
+          return_info: return_info
+          success: success
+        schema:
+          description: 获取设备级别的摘要统计信息
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result:
+              properties:
+                return_info:
+                  description: 设备摘要信息JSON格式
+                  type: string
+                success:
+                  description: 查询是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              type: object
+          required:
+          - goal
+          type: object
+        type: UniLabJsonCommand
+      get_plate_status:
+        feedback: {}
+        goal:
+          plate_num: plate_num
+        goal_default:
+          plate_num: 1
+        handles: {}
+        result:
+          return_info: return_info
+          success: success
+        schema:
+          description: 获取指定盘(1或2)的电池状态信息
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                plate_num:
+                  description: 盘号 (1 或 2)
+                  maximum: 2
+                  minimum: 1
+                  type: integer
+              required:
+              - plate_num
+              type: object
+            result:
+              properties:
+                return_info:
+                  description: 盘状态信息JSON格式
+                  type: string
+                success:
+                  description: 查询是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              type: object
+          required:
+          - goal
+          type: object
+        type: UniLabJsonCommand
+      print_status_summary_action:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result:
+          return_info: return_info
+          success: success
+        schema:
+          description: 打印通道状态摘要信息到控制台
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result:
+              properties:
+                return_info:
+                  description: 打印操作结果信息
+                  type: string
+                success:
+                  description: 打印是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              type: object
+          required:
+          - goal
+          type: object
+        type: UniLabJsonCommand
+      query_plate_action:
+        feedback: {}
+        goal:
+          string: plate_id
+        goal_default:
+          string: ''
+        handles: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties: {}
+              required: []
+              title: StrSingleInput_Feedback
+              type: object
+            goal:
+              properties:
+                string:
+                  type: string
+              required:
+              - string
+              title: StrSingleInput_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
+              title: StrSingleInput_Result
+              type: object
+          required:
+          - goal
+          title: StrSingleInput
+          type: object
+        type: StrSingleInput
+      test_connection_action:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        result:
+          return_info: return_info
+          success: success
+        schema:
+          description: 测试与电池测试系统的TCP连接
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result:
+              properties:
+                return_info:
+                  description: 连接测试结果信息
+                  type: string
+                success:
+                  description: 连接测试是否成功
+                  type: boolean
+              required:
+              - return_info
+              - success
+              type: object
+          required:
+          - goal
+          type: object
+        type: UniLabJsonCommand
+    module: unilabos.devices.battery.neware_battery_test_system:NewareBatteryTestSystem
+    status_types:
+      channel_status: dict
+      connection_info: dict
+      device_summary: dict
+      plate_status: dict
+      status: str
+      total_channels: int
+    type: python
+  config_info: []
+  description: 新威电池测试系统驱动，支持720个通道的电池测试状态监控和数据导出。通过TCP通信实现远程控制，包含完整的物料管理系统，支持2盘电池的状态映射和监控。
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        devtype:
+          type: string
+        ip:
+          type: string
+        machine_id:
+          default: 1
+          type: integer
+        port:
+          type: integer
+        size_x:
+          default: 500.0
+          type: number
+        size_y:
+          default: 500.0
+          type: number
+        size_z:
+          default: 2000.0
+          type: number
+        timeout:
+          type: integer
+      required: []
+      type: object
+    data:
+      properties:
+        channel_status:
+          type: object
+        connection_info:
+          type: object
+        device_summary:
+          type: object
+        plate_status:
+          type: object
+        status:
+          type: string
+        total_channels:
+          type: integer
+      required:
+      - status
+      - channel_status
+      - connection_info
+      - total_channels
+      - plate_status
+      - device_summary
+      type: object
+  version: 1.0.0